ABCDE Skills

Inspiration

The first time I let a coding agent loose on a real ticket, it did genuinely impressive work — and made a dozen decisions I never saw. A test strategy I wouldn't have picked. A refactor I didn't ask for. A behavior change buried in a 40-file diff. The code wasn't bad; I just hadn't steered it, I'd inherited it — all at once, at review time.

That's the trap with fire-and-forget agents: they're fast, but "fast" was never the bottleneck. Trust is. An unsupervised run surprises you far more than a process does.

ABCDE came from one conviction: agents are at their best when a human is steering and reviewing — and the way to make that practical is to make every change checkable, by a human and by CI, before it lands. Autonomy, without the surprises.

What it does

ABCDE is a todo lifecycle for agent-driven development: five composable skills, one per stage of a task's life, each a single slash command.

A — /add-todo — Park it. Capture any task as a written spec doc (docs/todo/<slug>.md) with frontmatter — status, priority, effort, tags. The spec, not the diff, becomes the first place intent is written down.
B — /brainstorm-todo — Sharpen it. Interrogate the open questions one at a time, fold every answer back into the doc, and flip it to ready only when it's genuinely buildable. Decisions get made before code, on paper, where they're cheap to change.
C — /code-todo — Build it. An isolated git worktree, an up-front impact assessment (unit/e2e tests, feature spec, API request collection, diagrams, contracts — each updated or a recorded "no change, and why"), green quality gates on every push, live screenshots, and a scoped PR. You approve the plan; then it runs to completion.
D — /deliver-todo — Ship it. Merge on green, tag the merge for traceability, tear down the worktree and branch everywhere — guarded so it never deletes unmerged work — and offer an optional stacked tech-debt PR.
E — /explore-todos — What's next. Keep the backlog visible, grouped by status, sorted by priority, with a staleness check against the code so it never lies.

The whole thing rests on one idea: keep autonomy on a leash by making every change reviewable.

How I built it

Each skill is a self-contained instruction set — a Markdown SKILL.md the agent reads and follows — installed with a single command:

npx skills add bishtbytes/abcde-skills

Instead of inventing new machinery, the skills lean on tools people already trust: git worktrees for isolation, GitHub PRs for review, and CI gates (type-check, lint, full test suite) as the floor every change has to clear. A task branches into its own worktree off develop, lands as one small PR, and develop only ships to main through a release PR a human approves.

The real test was dogfooding: every ABCDE skill was itself built and shipped through ABCDE, on a live 100k+-line monorepo. The workflow had to survive its own use — if a stage was annoying or unsafe, I felt it immediately and fixed it. I also built an interactive walkthrough of the whole lifecycle so the design was legible before it was code.

Challenges I ran into

Getting the agent to stop and decide up front. The hardest part wasn't generating code — it was making the agent surface its plan (tests, specs, diagrams, contracts) and wait for a human "go" before writing a line, instead of deciding mid-run.
Keeping everything in lockstep. Code drifts from its spec, diagrams go stale, saved API requests 404 the moment an endpoint changes. Making the impact assessment cover specs, diagrams, and an .http request collection — and update them in the same change — took real discipline to encode.
Making review genuinely cheap. Small, scoped diffs; screenshots captured and linked on the PR; a live preview server per worktree — so a reviewer meets the running change, not a wall of text.
Guarding agreed behavior. A neighboring feature can quietly break an agreement and still ship green. Encoding those as CONTRACT: tests that can't be silently weakened was key to trusting parallel agent work.
Safe teardown. Cleaning up branches and worktrees automatically — without ever deleting work that hadn't actually merged.

What I learned

The bottleneck in agent-driven development is trust, not throughput. Optimize the whole workflow for reviewability, and the agent's speed finally pays off.
Spec-driven wins. When the todo doc is the written source of truth, code, tests, docs, and the PR all flow from one place — and the reviewer reads intent, not guesses it.
Decide before, not after. Resolving decisions up front turns "review the surprise" into "approve the plan."
Small, isolated diffs are the unit of trust — and guardrails don't slow a good agent down; they're exactly what let you give it more rope.

What's next

Make it fully agent-agnostic (it's built to plug into your coding agent of choice), add team-shared backlogs and multi-agent parallelism across worktrees, and keep sanding down every point where a human has to think about mechanics instead of the actual decision.