Chat to Markdown Capability

A good conversation often holds your best thinking — decisions, drafts, and ideas. This Capability turns that chat into a clean, structured Markdown file your repository can keep, index, and act on long after the conversation closes.

What it is for

Use it whenever a session produced something worth keeping, or when work that started on your phone or in a cloud chat needs a durable home in your local repository. It is the bridge from “we talked about it” to “it is written down and findable.”

Frictions it removes

• Good ideas evaporating. Insights are saved instead of vanishing when the tab closes.
• Copy-paste mess. The session arrives as tidy, readable Markdown — not a raw dump.
• No record of why. The reasoning behind a decision is preserved alongside the decision itself.

How it works

The agent captures the conversation as a structured Markdown file, names and indexes it, and routes it toward the right destination — most often Instruction Capture for triage into Ideas or Plans.

Related

• Capability catalog
• Instruction Capture

GitHub Workflow Capability

Plain, copy-ready Git and GitHub steps so your work is safely backed up with a full history — no developer background required. It keeps GitHub as the durable record of everything you and your agent create.

What it is for

Reach for it after you have made local edits and want that work saved off your machine, or any time you need the exact commands to check status, pull, commit, and push. The steps are Windows-first and written to be pasted as-is.

Frictions it removes

• Git intimidation. Cryptic commands are replaced with a short, predictable sequence.
• Lost work. Pushing to GitHub means a stray mistake or a dead laptop never costs you your progress.
• Messy history. Clear, beginner-safe handoffs keep your commit trail readable.

How it works

The cycle is simple and repeatable: check status → review changes → commit → push. Each step comes with the literal command to run, and the agent only commits or pushes when you ask, so nothing leaves your machine by surprise.

Related

• GitHub Workflow page
• Capability catalog

Local Agent Tool Setup Capability

Gets a local agent tool — for example, Cursor — installed and configured on your own computer, pointed at your local copy of the repository. The workflow runs on your machine, where your files live, not locked inside a cloud-only tool.

What it is for

Use it the first time you set up a coding agent against your local Git clone, or when you need vendor-specific notes for a particular tool. It is the step that connects the method to a real application you can open and use.

Frictions it removes

• Setup guesswork. Clear steps replace trial-and-error configuration.
• Cloud-only limits. Working locally means faster, fuller access to your own files.
• Tool-by-tool confusion. Vendor notes live under Vendors/ so each app’s quirks are documented in one place.

How it works

The agent walks you through installing and configuring the tool, then points it at your local repository so passes run against the real files. Vendor-specific guidance is kept in Capabilities/LocalAgentToolSetup/Vendors/.

Related

• Agent Permissions
• Capability catalog

Situational Awareness Capability

Before an agent changes anything, it needs to know where it is, what has already been done, and which rules apply. Situational Awareness is that built-in orientation step — a quick look around the room before the work begins.

What it is for

Every agent pass starts here. It is especially valuable when you switch between working locally (in Cursor) and reviewing in the cloud (a ChatGPT planner), or when you paste in a handoff from an earlier session and want the agent to continue rather than start over.

Frictions it removes

• Repeated work. The agent checks what the last pass already finished instead of redoing it.
• Edits in the wrong place. It confirms the real source of truth — your local Git repository — before touching files.
• Cold starts. A pasted handoff is read and understood, so context is not lost between sessions or tools.

How it works

The agent reads its boot files, detects whether it is running locally or in a cloud planner, scans recent task notes for unfinished work, confirms the source of truth, and only then routes to the right Capability and begins editing.

Related

• Capability catalog
• AI Workflow

Assisted Agentic Workflow Capability

This is the everyday rhythm for working with an AI agent inside your repository. Instead of one giant prompt and a tangle of follow-ups, the work moves in a steady, owner-supervised pass cycle: plan a small step, do it, summarize what changed, and hand off cleanly to the next pass.

What it is for

Most repository work — drafting, fixing, organizing, deciding — does not fit a single narrow Capability. Assisted Agentic Workflow is the dependable default for all of it. You stay in the driver’s seat while the agent does the legwork in pieces small enough to review and approve as you go.

Frictions it removes

• Reinventing instructions every session. The cycle is the same each time, so you do not have to re-explain how you like to work.
• Runaway changes. Small, reviewable steps keep the agent from doing too much at once and burying mistakes.
• Losing the thread. Every pass ends with a short summary, so picking back up later is effortless.

How it works

1. Plan the next small, concrete step together.
2. Implement just that step.
3. Summarize what changed and why.
4. Hand off so the next pass — or a fresh session — starts with full context.

Related

• Capability catalog
• How It Works

Repository Scaffold Capability

Keeps your repository tidy and predictable. It defines where Capabilities, Plans, and your own folders are meant to live, and it repairs the core structure when something is missing — so the project grows in a sensible shape instead of sprawling.

What it is for

Reach for it when you are unsure where a file or folder belongs, when expected scaffold files are missing, or right before a setup step that needs to create new paths. It is the map of the intended repository tree.

Frictions it removes

• Random folders. Stray directories from unrelated tasks are avoided.
• “Where does this go?” Placement questions have a clear, documented answer.
• Drift over time. The core structure is repaired and kept consistent as the project grows.

How it works

The agent compares your repository to the intended growth tree, repairs or recreates any missing core folders, and guides new files to their correct home — so structure stays deliberate rather than accidental.

Related

• Capability catalog
• The Get Established Method

Manual Indexing Capability

The default way a Get Established repository stays findable. As new durable files appear, the agent updates the indexes by hand — no scripts, no build tools, nothing extra to install or maintain.

What it is for

Use it whenever new Markdown files need index metadata or the navigation indexes need a refresh. It is deliberately the default for starter repositories, where simplicity matters more than automation.

Frictions it removes

• Stale navigation. Indexes stay current as content is added.
• Automation overhead. No scripts to set up, run, or debug.
• Lock-in. A plain, by-hand approach works the same on any machine.

How it works

When new durable files land, the agent updates the Indexes/ entries and the index frontmatter directly, following the shared Indexing format so everything stays consistent and easy to scan.

Related

• Indexing
• Capability catalog

Indexing Capability

The shared format and health-check that lets an agent find your Goals, Plans, Capabilities, and Skills quickly. Indexes are lightweight signposts that point at your real files, so nothing has to be hunted for.

What it is for

Use it when you have a question about the index format, when a repository needs its Indexes/ set up on adoption, or when you want a quick, read-only health review before a large pass of work begins.

Frictions it removes

• Hunting through the repo. Agents find the right file fast instead of searching blind.
• Inconsistent formats. One shared structure keeps every index readable the same way.
• Silent rot. A health check surfaces gaps and stale entries before they cause trouble.

How it works

This Capability defines the common index format and a read-only health check. Indexes always point at source files — they never become the files themselves. The day-to-day work of keeping them current is handled by Manual Indexing.

Related

• Manual Indexing
• Capability catalog

Mirror to Windows Capability

When you ask for it, this Capability copies your local repository to a cloud folder — Dropbox or Google Drive — so a ChatGPT planner can read it. The mirror is a review copy only; it is kept separate from Git and never connected to your remotes.

What it is for

Use it when you want to review or plan in the cloud and need an up-to-date copy of your work there. It is an on-demand step you trigger after local edits, once you have approved a review sync — not something that runs in the background.

Frictions it removes

• Manual file copying. One step refreshes the whole review copy instead of dragging files around.
• Backup confusion. GitHub stays your durable record; the mirror is clearly just for review.
• Accidental cloud copies. The default is no cloud copy, so files only leave when you say so.

How it works

On request, the agent performs a one-shot refresh from your local Git repository to the owner-chosen cloud folder. It also covers the vendor aliases Mirror to Dropbox and Mirror to Google Drive, which run the same workflow.

Related

• Capability catalog
• Dropbox Link · Google Drive Link

Google Drive Link Capability

Runs the ChatGPT planner loop for owners who review their work through a Google Drive connector. It ties together intake, capture, and a cloud copy refresh into one smooth flow, so planning away from your desk stays connected to your repository.

What it is for

Use it for a remote planning session when you do not have your local workspace in front of you and you have chosen Google Drive as your review channel. It is how a cloud conversation feeds real changes back into your project.

Frictions it removes

• Disconnected planning. Planner and worker stay in sync instead of drifting apart.
• Manual shuttling. Moving notes between chat and repository happens as part of the loop.
• Setup ambiguity. The Google Drive review path is defined once and reused.

How it works

The Capability handles intake and capture from the planner session and delegates the cloud copy refresh to Mirror to Windows. Git itself is never linked to Google Drive as a remote, and routine local-only passes need none of this.

Related

• Mirror to Windows
• Capability catalog