What coding agents should decide, and what they should ask you
Human in the loop AI coding agents either get a novel to rubber-stamp or redo a call the team already made. Write down what the agent decides, keep each ask to one decision, and leave the merge with a named person.
A human in the loop for AI coding agents does nothing if the ask is a novel. The person clicks approve. It also does nothing useful if the agent redoes a call the team already rejected. Write down what the agent decides on its own. A named person gets the rest. Each ask is one decision, with the default filled in. The decision and the reason stay on the card. A person merges.
The ask got too long to read
On r/ClaudeAI, Field report: agentic coding in an enterprise project by u/LouisObsidian is filtered by automod, so this is a link. u/LouisObsidian wrote:
They start writing pages of deliberation to the “human in the loop”, so much that the humans can’t keep up. And you can’t remove the human, because someone has to be accountable in the end.
And:
About an hour later, a giant .md file landed in my inbox. Already the first paragraph was full of deliberation about things that didn’t matter. I was tired, I didn’t read it, I clicked approve.
The dollar figures in that post are theirs. I am not using them. Yup. I have approved a file I did not read. tbh the ask was not a decision. It was a document, and the person who was supposed to be accountable had already stopped reading.
If you are vibe coding with Claude, at some point you are not able to even remember what you assigned it.
So today I integrated @linear with my Claude, and now Claude:
> creates the projects
> creates the tickets
> assigns the tasks with different labels
> moves the tickets itself
Now I can track each and everything I have given to Claude.
Even as a solo developer, it's very important to track stuff.
How are you managing your tasks with AI?
sankit posted that on November 11. "If you are vibe coding with Claude, at some point you are not able to even remember what you assigned it." He wired Linear to Claude so the assignments would sit on a board. If the questions are already visible there, stay there. I compared the boards in Kahoona vs Linear.
Two agents reviewing each other
I tried to let Claude Code and Codex review and fix each other's PRs. It spiraled into nits and bloated PRs, and I couldn't prompt my way out.
That’s one of many learnings from a year of running coding agents. Commits went up 3.7x along the way. Improvements came from finding where I was the bottleneck and removing myself:
1. Managing many coding agents got much easier with ADEs like Conductor @conductor_build (btw congrats on the acquisition)
2. Then running dev servers in parallel became the bottleneck. Spotlight is nice but only one session can run at a time. Took some effort to fix the dev env so each agent boots its own stack on its own ports. Also had to share dependencies so thousands of worktree dev envs don't blow up disk space.
3. Then validation became the bottleneck. Playwright MCP made browser validation much easier. I gradually moved to Codex browser and computer use (still better than Claude Code here) driving my main browser and laptop end to end. They now also handle my misc ops tasks, like reading FullStory sessions, setting up accounts, and updating website configs.
4. Then correctness became the bottleneck. To improve a non-deterministic agent, I let the coding agent run an eval-driven loop: write evals and confirm the agent fails them -> fix -> evals pass.
5. Then figuring out what to fix became the bottleneck. Now auto research agents dig through aggregated customer signals (e.g. intention mismatches), propose PRs on their own with the above techniques, and merge the low-risk ones.
What I still can't hand off:
Figuring out what to build. Getting real world feedback, a sense of where tech and the industry are going, and getting everyone aligned still takes a lot of human involvement.
Architecture. Coding agents with frontier models still don't hold the full picture. Their changes are often scoped narrowly.
Review. On the PRs I still merge myself, I rarely read line-level logic anymore, but over-engineering and weird implementations still get through.
So agents own execution and verification. I own what to build, architecture, taste, and saying when it's done.
Yunfeng Bai posted that on November 10. "I tried to let Claude Code and Codex review and fix each other's PRs. It spiraled into nits and bloated PRs, and I couldn't prompt my way out."
The 3.7x commits in that post is his number. I have not measured it. The lines I use are the ones about what he still can't hand off. "Figuring out what to build." "Architecture. Coding agents with frontier models still don't hold the full picture. Their changes are often scoped narrowly." "Review. On the PRs I still merge myself, I rarely read line-level logic anymore, but over-engineering and weird implementations still get through."
His closer is the split. "So agents own execution and verification. I own what to build, architecture, taste, and saying when it's done."
Execution and verification can run. What to build, the architecture, taste, and saying when it is done stay with a person. Later in the same post those agents merge the low-risk changes. I don't. The merge stays with the person named on the card. Who that person is, before the run starts, is in Name a human owner before the agents open pull requests.
Knowing which suggestion to approve
Someone put a whole game studio inside Claude Code: 49 AI agents, 72 skills, 37k stars, and the repo picked up 4.3k of them in just 7 days.
ONE PERSON, ONE CLAUDE CODE SESSION, AND A FULL STUDIO ORG CHART OF AI AGENTS. THE ONLY QUESTION LEFT IS WHO MAKES THE DECISIONS
The video shows this repo's page on GitHub, scrolled from the file list down through the README. The swarm of cursors is a visual effect I added on top.
The project is called Claude Code Game Studios. Its own description says:
"Turn Claude Code into a full game dev studio — 49 AI agents, 72 workflow skills, and a complete coordination system mirroring real studio hierarchy."
It's MIT licensed, so you can use it, change it and build on it.
Here is what's inside.
The team. The 49 agents are organized the way a real studio is: directors on top, department leads under them, specialists at the bottom. Roles in the repo include a creative director, a technical director, a producer, an art director, a QA lead and a release manager. There are also agent sets for the engines people actually use: Godot 4, Unity and Unreal Engine 5.
The skills. 72 workflow skills work as commands you type inside Claude Code. Examples: /start for guided setup, /brainstorm, /dev-story, /code-review and /release-checklist.
The guardrails. The repo ships path-scoped coding standards for gameplay, engine, AI, UI, network and asset files, plus scripts that check commits, pushes and asset changes. The agents work inside rules, not just on vibes.
The workflow. It runs from brainstorm all the way to launch: design, stories, implementation, QA, release. Templates for game design documents, architecture decision records and sprint plans come with it.
And here is the part that matters. The repo says you, the developer, keep making every decision. The agents ask questions, offer options and catch mistakes. You approve.
Setup is short: clone the repo, open Claude Code in the project folder, and run /start.
The numbers: about 37k stars and 4.9k forks. The repo was created on February 12, 2026, so that's roughly nine months. About 4.3k of those stars came in the last 7 days.
Here is the link: https://t.co/EGDSMliyBF
Think about the size of the idea. A studio isn't one skill. It's a pipeline of roles that argue with each other, and this repo tries to copy the arguing, not just the typing.
My take: the interesting part isn't that AI can write game code. It's that the repo copies how a studio makes decisions. If it works, the scarce skill won't be programming. It will be knowing which of 49 suggestions to approve.
What I haven't verified: I haven't run this repo or opened its page myself. The counts of 49 agents and 72 skills are the repo's own claims, and the summaries I found disagree on the exact breakdown, so treat them as claims until you've counted. The star, fork and growth numbers come from a tracker page dated November 9 and change by the hour. The repo is free, but Claude Code usage itself can cost money. The label at the bottom of the video ("agents", "layers") belongs to the cursor effect, not to this repo. The video is a screen recording with that effect added, not a demo of the agents running.
So can one person plus 49 agents ship a real game, or just a very well-organized pile of prototypes?
fayzonnn posted that the same day, about a repo that puts a studio org chart inside one Claude Code session. "ONE PERSON, ONE CLAUDE CODE SESSION, AND A FULL STUDIO ORG CHART OF AI AGENTS. THE ONLY QUESTION LEFT IS WHO MAKES THE DECISIONS" and "If it works, the scarce skill won't be programming. It will be knowing which of 49 suggestions to approve."
The 49, and the star counts in that post, are his. He says he has not run the repo or opened its page. I have not either. I am not repeating those counts as facts. The question in the first line is the one that matters. Who makes the decisions.
Approval gates that fit on one screen
On r/ClaudeAI, the post body of my claude code agents raised 368 approval gates last week. 17 needed me was removed. Those two numbers are the title. I am not using them as a count. I am quoting comments.
u/jijialuoke wrote:
For approvals my line is similar: anything I can undo with a git revert gets auto-approved, anything that touches money, keys or prod waits for me.
Yup. That is the line for what an agent decides on its own. If a git revert puts it back, the agent does not ask.
u/Specialist_Bison_737 wrote:
The human gate sits between steps: merging the PR, and anything with spend, keys or prod.
And:
Gates pile up in long-running sessions.
The rest of that comment is a tool. I have not used it, and I am not describing it. The second sentence is the failure mode. AI agent approval gates pile up, and then you are back to clicking approve on a page you did not read. If the gate is not one decision, it is another document.
u/anamethatsnottaken wrote:
I find I can let agents go wild on whatever they want as long as "irreversible" changes are done when I'm online
Irreversible waits until a person is there. I want the name on the card before the run, not a hope that someone happens to be at the keyboard.
A revert does not cover the rest of the calls I will not hand off. Money, or anything that spends. Keys and secrets. Prod and data. Anything you cannot undo. Brand, and anything public. What to build. Architecture. Those come to a named person, and the agent stops.

Paste this on the card
The rules, at the top of the description. {name} is the person who merges.
Agent decides:
- A change a git revert can undo.
- How to implement a decision already written on this card.
- The checks, and a fix when those checks fail.
Ask {name}, and stop:
- Money, or anything that spends.
- Keys, secrets, or credentials.
- Prod, or data.
- Anything a git revert cannot undo.
- Brand, or anything public.
- What to build.
- Architecture.
The decision and the reason stay in this description. Do not reopen a decision that is already written here. Do not delete these lines.
The ask, when the agent is actually blocked. One screen. Yes or no, or pick one. The default is the answer you want if you are busy.
Ask: {yes/no, or pick one}. Default: {the answer if you hear nothing}.
Why it is blocked: {one sentence}.
Already decided: {the line on the card, or none}.
Waiting for: {name}.
If the ask needs a paragraph, it is not an ask yet. Decide it yourself when the rule says the agent can, or split it until a person can answer in a word. The longer handover, for when a line is not enough, is in A status update template for agents: BLUF, then SBAR.
The rejected decision has to be on the next card
I made this. Kept hitting the same thing: the agent does something reasonable that we'd already decided against. The reason was sitting in a Jira ticket or a Slack thread, and a CLAUDE.md only helps until it goes stale.
Hooking up the Jira and Slack MCP servers didn't fix it for me either. The agent only searches when it thinks to, it gets back threads rather than decisions, and nothing tells it which of two answers still stands.
The clip is a demo repo with one ADR in it. Align reads decisions from wherever they actually got made (Jira, Confluence, Linear, Notion, Slack, Teams, Zoom, GitHub, GitLab, git history, repo docs), and before the agent edits it checks the change against them, whether or not it thought to look. If it clashes, it stops and asks you.
It also links decisions to each other, so when a newer one replaces or contradicts an older one, the agent sees both instead of whichever it found first. With a model key it marks which one replaced which.
Free and open source, runs on your machine, works with Claude Code, Codex, Gemini CLI and a few others.
`npm i -g @aligndottech/cli`, then run `align`
Repo: [github.com/aligndottech/align-cli](https://github.com/aligndottech/align-cli)
What I'd genuinely like to hear: when a newer decision quietly contradicts an older one, how does your setup cope? That's the bit I found hardest.
u/chronicideas wrote: "the agent does something reasonable that we'd already decided against. The reason was sitting in a Jira ticket or a Slack thread, and a CLAUDE.md only helps until it goes stale."
The rest of that post is a tool. I have not used it, and I am not describing it.
Yup. A reasonable change is how a rejected decision comes back. The reason was in a ticket or a thread the next session never opened. A CLAUDE.md rots. I put the decision and the reason on the card the next session is pointed at. A shared markdown backlog has the same hole once two people and two agents are in the repo. That writeup is A markdown backlog for AI coding agents. If the company already lives in Jira, stay there. That comparison is Kahoona vs Jira.
What Kahoona does with this
I built Kahoona, so weigh this part.
The list above is a rule you keep. Kahoona does not read it, and it will not stop an agent that spends money, writes a secret, or picks an architecture. There is no approval-gate field.
Put the decision in the card description, at the top. get_task returns that description. update_task replaces it, so a session that rewrites the card has to keep the decided lines. Tell Claude Code, Cursor, or Codex to call get_task before it edits. How you connect them is in Let Claude Code and Codex pick up tickets from your board with MCP.
A comment is what a person reads in Activity. comment_on_task posts there. Kahoona's own agent is given the description and the last 20 comments when it starts. Each comment is cut at 1,000 characters, and the description is cut at 8,000, which is why the decision goes at the top and stays short. While the run is still queued, it reads the last 12 comments to decide whether the job is code or a reply. That text is handed over as untrusted card data. The prompt tells the agent not to follow directions written inside it, so a rules block is not a system instruction and it is not a gate. It is the spec on the card.
MCP has no tool that lists those comments. A Claude Code, Cursor, or Codex session that only calls get_task does not see a decision that lives only in a comment. Write it in the description. Use the comment for the one-screen ask, and for the answer.
There is a project memory store, and remember can save a decision. The tool list says to check memories before acting. Memory writes are off until the project allows them. The default is off, and remember returns an error when they are off. The agent is also told to ask you before it records one. I keep a rejected decision on the card, because that is what you point the next session at. Memory is extra, and only if you turned it on.
While Kahoona's agent is running, it can post a question. The card shows Question for you. The instruction it is given says to ask, then carry on with its best assumption and say which one it made. A question does not pause the run. A note is capped at 1,000 characters. The app does not force the ask to be yes or no. That shape is yours. If you need the run to stop, say so in the rules, and use the Stop button when it does not. You answer on the card. While the run is going, the reply reaches the agent on its next step, and Question for you clears. If the run has already stopped, the reply waits until someone retries it.
When a code run stops, the card says Needs you. If you assigned the card to the agent, it goes back to the person who asked, as long as the card is still assigned to the agent and that person is still in the workspace. The card says Back to that person. If they have left, the card is unassigned. A card someone already gave to another person is left alone. A mention does not hand the card back. The card stays with its owner. Whoever retries the run is the person it goes back to next time.
Checks run on the agent's own computer. A repo can set them in WORKFLOW.md, up to eight commands. Otherwise it uses the commands saved on the project, or, when neither is set, the typecheck, test, lint, and build scripts from package.json, run with the package manager the lockfile names. A review runs no checks and opens no pull request. A code run can try to fix a failing check twice. If they still fail, the pull request stays a draft, the card says Needs you, and the comment names the draft. If they pass, or if no checks are configured, the pull request is marked ready and the card moves to review. I do not treat those on-computer checks as the gate. They ran on the agent's tree. GitHub's CI is the check on the pull request. A failed GitHub check is recorded on the linked card and does not move it. The standup can list that open pull request as stuck. It still does not merge.
A person merges. Kahoona's agent never merges and never deploys. There is no merge tool. The pull request says so. A merge moves the card to Done when the title or body uses a closing word, such as fixes WEB-14, and the merge lands on the branch the project watches. A Claude Code, Cursor, or Codex session you start yourself is a different door. Kahoona does not attach to that terminal, and it will not stop the session from merging if GitHub lets it. The merge gate for those sessions is the rule you wrote, and who has permission on the repo.
One project runs one Kahoona agent at a time. The database allows one running row per project, and the saved setting is 1. You cannot raise it. The other cards wait, as Next up or #2 in line. A free account also refuses a third in-progress run. In progress counts a queued card and a card waiting on a person, not only the one that is coding. The message is that you already have 2 agent runs in progress. That 2 is the free default in the code. The same defaults allow a paying workspace more in-progress runs. The one running agent per project does not change.
How I sort the pull request after it lands is in How to review AI agent pull requests without drowning.

When Kahoona is the wrong board
If the questions are already on Linear, stay there. Kahoona vs Linear. If the company already lives in Jira, same answer, in Kahoona vs Jira.
Kahoona is the wrong tool when you want the app to enforce the rules list, or when you want a question to freeze the run until you answer. It will not. The card holds the decision. A person merges. It is also the wrong tool when you want the agent to merge.
Kahoona is free for one person. On a team the first chair stays free and each extra chair is $5 a month, so five people pay $20 and ten pay $45. No card to start. It is a web app.
Write the split on the card. Keep the ask to one decision. That person merges.