How I Develop

I run many Claude Code sessions in parallel and keep myself in the loop only where a human decision matters. Most of the workflow below is backed by tools I built and publish on GitHub.

The flow of one task

A task starts from my request, goes through a plan, decisions and implementation by Claude Code, is reviewed by AI agents and then by me, and ends with a retrospective that feeds new rules and follow-up tasks back into the loop.

flowchart TD
  req([Me, with a request]) --> task[Task on Kaneo board]
  task --> clone[Own clone via ccx]
  clone --> plan[Plan in markdown]
  plan -->|extract decisions| queue[Decision queue in markdown]
  plan <-->|line comments via MCP channel| me([Me, in akapen])
  queue <-->|answers via MCP channel| me
  plan --> work[Agent works]
  queue -->|decided| work
  work -->|new decision| queue
  me -->|question| qa[Q&A document in markdown]
  qa <-->|answers / line comments via MCP channel| me
  work -.->|approval for irreversible actions| me
  work --> verify[Verify: tests must fail when the code is broken; observe the real effect]
  verify --> pr[Pull request]
  pr --> review[Adversarial review by Claude Fable]
  pr --> ext[External reviews: Antigravity, Copilot, Codex, CodeRabbit]
  review --> myreview([Me, reviewing the PR])
  ext --> myreview
  myreview --> merge[Merge]
  merge --> retro[Retrospective]
  retro -->|proposals| fable[Proposal review by Claude Fable]
  fable -->|adopted: new rule / skill / tool| rules[(Rules repository)]
  rules <-.->|periodic cleanup| cleanup[Consolidate and prune rules]
  rules -.-> work
  retro -.->|follow-up tasks| task
  classDef human fill:#dbeafe,stroke:#1d4ed8,color:#1e3a8a
  classDef claude fill:#fde2c4,stroke:#c2410c,color:#7c2d12
  classDef other fill:#dcfce7,stroke:#15803d,color:#14532d
  classDef store fill:#f3f4f6,stroke:#6b7280,color:#374151
  class req,me,myreview human
  class task,clone,plan,work,verify,queue,qa,pr,review,merge,retro,fable,cleanup claude
  class ext other
  class rules store

blue is me, orange is Claude Code, its subagents and what they produce, green is other AI agents, gray is a repository.

One session, one scope

• Each agent session owns exactly one task and works in its own clone of the repository.
• Clones are created by ccx as fully independent copies in under a second, so several sessions can check out the same branch without git worktrees.
• Every session is attached to a task on a self-hosted Kaneo board through kaneo-cli, so I can see which session is working on what, and the next step is recorded before a session leaves.
• When a session wraps up, follow-ups that outlive it become new tasks on the board instead of notes in the chat, so a later session can pick them up.

Sessions supported by ccx-agent

• A resident ccx-agent runs on every machine, takes Claude Code hook events and forwards them to one ccx-center, so a single CLI lists every session on every machine.
• It also stores live transcripts, so a finished session can be searched, or resumed on another machine.
• Idle sessions I opt in are kept warm by the agent, so their prompt cache stays hot while they wait for my answer.

Humans decide, agents keep moving

• Reversible choices are made by the agent and reported afterwards.
• Irreversible or outward-facing actions wait for my explicit approval.
• Before implementing, the agent writes its plan as markdown and extracts every point that needs my decision into a separate decision queue, so the plan stays a plan and the questions are in one place.
• I review both in akapen with line comments: the plan for direction, the decision queue for answers.
• akapen is registered as a Claude Code MCP channel, so each comment is pushed into the running session the moment I write it. The session revises the plan or applies the decision and replies on the thread, so I steer from inside the loop instead of rewriting prompts.
• Decisions that come up during implementation go to the same queue, and the agent keeps working on whatever does not depend on them.
• When I ask a question, the answer goes into a Q&A document in markdown rather than the chat. Follow-ups are line comments on that document, so the answers stay readable later instead of scrolling away.
• Design discussions also happen in markdown reviewed line by line, not in a scrolling chat.

Rules as code

• Agent behavior lives in a versioned repository: global instructions, task-specific skills, hooks that block known mistakes, and small CLIs.
• Changes to those rules go through pull requests like any other code.

Every session ends with a retrospective

• When a session’s scope is done, it runs a retrospective before closing instead of just stopping.
• The retrospective reads the session itself: my corrections, the comments I left in akapen, and the commands the agent actually ran.
• What went wrong becomes a new rule, a skill or a tool, and what was tedious becomes a candidate for automation. A reviewer agent running on Claude Fable decides which proposals to adopt, and they are merged through pull requests.
• Rules only help while they stay readable, so they are periodically consolidated and pruned: duplicates merged, outdated ones removed, and examples moved out of the always-loaded instructions.
• The next session starts with the improved rules, so the development process itself improves one session at a time.

Review and verification

• Every pull request gets an adversarial review by a dedicated agent on Claude Fable playing the strictest human reviewer, plus independent reviews from other model families (Antigravity, GitHub Copilot, Codex and others) and CodeRabbit.
• After the AI reviews are done, I review the pull request myself before it is merged.
• Tests are checked with negative controls: the implementation is deliberately broken to confirm the test actually fails.
• When acceptance tests can be written first, implementation is delegated to a smaller model, while the main agent keeps the spec, the tests and the acceptance check.
• ”Done” means the effect was observed, not that the code ran.

Everything leaves a record

• Investigations, setups and abandoned attempts all end as a markdown note merged into a knowledge repository.
• Session history is searchable with cchist, and commits and pull requests carry a session id so any change can be traced back to the conversation that produced it.