How we built autonomous mode for Claude Code projects
Claude Code is good at individual tasks. You describe what you want, it writes code, you review it, and you move on.
That works well for a feature, a bug fix, or a focused piece of implementation work.
But project work has a different kind of overhead.
Once the backlog is real, the work is no longer just writing code. Someone has to decide what comes next, check whether the ticket is blocked, write a plan, review that plan, run the implementation, review the code, update the project state, and make sure the next session knows what happened.
ClaudeStory was built to reduce that overhead across a project. Autonomous mode is what happens when the system is structured enough that Claude can handle those transitions on its own.
How it connects to ClaudeStory
ClaudeStory keeps project state in a .story/ directory inside the repo. Tickets, issues, handovers, roadmap phases, and session state live there as structured local files.
The Mac app turns those files into a live project view. You can see tickets on a board, issues in a tracker, handovers across sessions, and the overall shape of the work as it moves.
Autonomous mode is built on top of that same foundation. It is not a separate system. It uses the same project state that makes normal Claude Code sessions easier to manage.
What autonomous mode actually does
Autonomous mode is for work that is already clear. The ticket exists. The scope is known. The main question is not "what should we build?" but "can this move forward without pushing every step manually?"
When you start autonomous mode, ClaudeStory works through a structured pipeline: select work from the backlog, plan the implementation, review the plan, implement the approved approach, review the code, update project state, commit, and move to the next eligible ticket.
This is not Claude writing code in a loop. It is Claude moving through a workflow with project state, review gates, and continuity built in.
It means clear work can keep moving without you manually pushing every transition.
Why the review process matters
The review process is what makes autonomous work credible instead of reckless.
Before code is written, the plan goes through independent review by Codex, a model from OpenAI. After implementation, the code goes through another review pass. Using a separate model from a different provider matters because it brings different training, different biases, and different blind spots to the work.
Review depth scales with the size and sensitivity of the change. Small changes get lighter scrutiny. Sensitive or high-impact work gets deeper review.
The point is not to pretend the system is infallible. The point is that autonomous work follows a review process you would actually want on a real project: independent verification, not self-review.
Why continuity matters here
ClaudeStory writes handovers that capture what happened in a session, what decisions were made, why those decisions were made, what is still open, and what should happen next.
Git history can tell you what changed. Handovers explain why.
That becomes especially important once work spans multiple sessions or multiple tickets. The system is not starting from scratch each time. It is continuing from project state.
Why the dashboard matters
Autonomous mode should not feel like a black box.
The Mac app lets you see what Claude is doing while the work is happening. Ticket status changes show up as the project state updates. Handovers appear as they are written. The board reflects progress in real time.
Instead of wondering whether an autonomous run is doing something useful, you can open the app and see the work move. You can see what is active, what finished, what got blocked, and what changed.
Autonomous mode is more useful when you can watch it and step in when needed.
What it is good for
It works best when the work is clear and bounded: working through a backlog of well-scoped tickets, finishing implementation once the approach is known, repetitive structured work where the pattern is clear, or moving a project through follow-through work that benefits from consistency.
Not because it replaces judgment, but because it removes the need to manually push every transition from one step to the next.
Different levels of autonomy
The same workflow runs at different levels. You can use it to work through tickets autonomously. You can use it for a single guided ticket. You can use it to generate and review a plan before implementation. You can use it to review code against a ticket after the fact.
Most real projects do not live at one setting all the time. Some work is clear enough to let run. Some needs review checkpoints. Some just benefits from a stronger planning step.
ClaudeStory uses the same project state, handovers, and workflow structure across all of those modes.
The bigger point
Autonomous mode is not the whole product. It is a power feature built on the same foundation that makes regular Claude Code sessions better.
The tickets define the scope. The reviews enforce quality. The handovers preserve continuity. The local files keep project state inspectable. And the dashboard gives you one place to see what Claude is doing across the project.
When the work is structured and visible, Claude can keep moving. And you do not have to lose track of the project while it does.