DEV Community

Cover image for Autonomous Software Development for Non-Developers: How a Claude Code Plugin Enforces the Development Lifecycle
Stamatios Metaxotos
Stamatios Metaxotos

Posted on AI-assisted

Autonomous Software Development for Non-Developers: How a Claude Code Plugin Enforces the Development Lifecycle

You built a feature with AI. How do you know it works as intended and didn’t break anything else? After more than 4,000 hours using Claude Code, I built a plugin for exactly that problem.

If you’ve tried building software with a coding agent, some of this might sound familiar:

  • You know what you want to build. You don’t necessarily know every step of the software development lifecycle or when to ask the agent to take it.
  • The feature works the first time you try it. You still have to ask: “What happens if someone submits the same request twice? Do the features that depend on it still work?”
  • The agent asks which library or architecture you prefer. That’s one of the decisions you expected it to handle.
  • You leave it working, come back, and find it waiting for you to type “proceed” on a step you already approved.

Meta-XoT-OSS-Rail is a free, open-source plugin for Claude Code. You describe what you want, and it takes the work all the way to the end, by itself. It does not stop halfway: it pauses to ask you only what is yours to decide.

Ask an AI for a feature, and you get a feature. This plugin aims higher: a feature that went through every required step of a proper development process, the code studied, the change planned and built, and, on the full way, tested, with every stage checked by a separate AI reviewer before the next one starts. It cannot mark its own work as finished.

You answer business questions, not technical ones. Claude asks you what the work should do, in plain words. Technical choices (which library, pattern or code) are made by the agent, which is usually better at them than someone who is not a developer, and checked by its reviewer, except a stack the work needs and your project does not have: then you choose from up to three options, explained in business terms. You answer mostly with a click; the plugin runs the process.

Also yours: risky actions. Changing how the process runs, ending a run early, or a command that deletes folders or throws away work not yet committed happens only with your explicit approval.

It works on one piece of work at a time (a feature, a fix, a plan, a design), so you could build a whole project with it, one piece after another.

Get it on GitHub, free and open source. How to install it is in the README, the guide on the repository's front page. This is the first public version, and feedback is welcome.

Who it is for

  • You don't know the steps of a proper development process. You tried building with an AI, and it did not finish the job.
  • You got something that worked once, but was not robust — not tested, not built the way software should be.
  • You are asked too many technical questions you cannot answer.
  • You are tired of checking the agent all the time.
  • You have an idea, no prior dev experience, and you want a solid first version of it.

How the idea came

At a seminar I watched an AI learn to play an old Atari game, Breakout — the one with a bar and a ball. It was DeepMind's program, the one described in Nature in 2015 (Human-level control through deep reinforcement learning; DeepMind's own explanation: Deep reinforcement learning). Nobody told it how to play. It was given the screen and the score, and it learned by chasing a higher score. After a while it found a trick nobody had shown it: dig a tunnel through one side of the wall and let the ball bounce around behind it.

That stayed with me. If a machine can learn to play well when the rules and the score are clear, why can't building software be a game too?

So I turned the development process into one:

  • The rules became hooks. Claude Code runs them, and they refuse the moves the process does not allow. The repository's README lists the few they cannot see.
  • The levels became the stages of the process. The stages are a context map (your request, how things work today, and what is still unclear), a plan (the technical specification and the rules the finished work must meet), the build, a testing plan, and the test run. Each one is followed by its review, so each level has two steps.
  • The points became the score. Each step has a maximum to reach, and the game is not won when the agent says the work is finished. It is won when every required step is completed or accepted by you. A review counts as completed only when a separate AI reviewer passes it.
  • The players' moves became skills, the written instructions Claude follows, one for each step.

Breakout is the inspiration, not proof that the plugin works. The two work differently. DeepMind's program learned by trial and error, changing itself to get a higher score. My plugin trains nothing: it keeps an existing model on a fixed track, and the score tells it which step comes next and when it may stop.

How a run works

A run is one piece of work, from your request to the finished work, saved in your project's history. You start it by typing one command with your request — type it, do not paste it: a pasted command can arrive as plain text and start nothing. For example:

/metaxotrail:00-ship add a CSV export to the orders page
Enter fullscreen mode Exit fullscreen mode

Claude first asks how to start (fresh, from earlier work, or after you add details); your click starts the run. Then it goes through the stages of the process by itself:

  1. Context map. Claude writes down your request word for word, so the finished work can be compared with what you asked. It studies how the code works today: where things start, how data moves, which files are involved, and what the project already has that can be reused. It reads the git history (git is the tool that keeps your project's history) to see how this code came to be, and searches the web for known problems with this kind of change. What it cannot find out is written down as an unknown, with the risks, and turned into questions for you, when only you can answer them — not guessed.
  2. Plan. The technical specification. Claude weighs a few options, each with its pros, cons and risk, and recommends one. It writes down its assumptions and how each will be checked. It writes the rules the finished work must meet, before anything is built, so the reviewer has a clear list to check the work against. It lists what could go wrong and how to undo the change. And it splits the work into parts, each with how it will be tested.
  3. Implement. Claude builds one part, and only that part: no extra changes on the side. It follows the patterns the project already uses, checks its own work by running it, and stops to ask you when something only you can answer is unclear, rather than guessing. Once a part is built and reviewed, its code is frozen until it is delivered.
  4. Testing plan. Claude writes how that part will be tested: the normal cases, the unusual cases and the errors, each with a result that can be measured, and the most important first.
  5. Run the tests. Claude runs the tests one at a time and records what really happened, with the evidence: pass, fail, suspicious, or not run, with the reason. Claude is told never to mark a test as passed when it did not pass, and the review after this stage looks for exactly that.

Stages 3 to 5 run for one part, then for the next.

Each stage is followed by its review, by a separate AI agent that did not write the work and cannot edit it. The reviewer starts without the conversation and checks the work against the code. The map, the plan and the build are also checked against your original request. It grades each problem it finds. If it finds a serious problem, Claude fixes it and the review runs again, until it passes; small problems are recorded. A review that finds an earlier step was wrong sends the work back there. Claude stops only to ask you something that is yours to decide. You can end a run whenever you choose: ask Claude, and confirm with the one line it gives you; the run closes with the score it reached.

Risky actions wait for you. Some decisions are too important to leave to the agent: overriding the process (closing, reopening or sending back a step on your own authority), ending a run before it is finished, and commands that would delete folders or throw away work not yet committed. During a run, Claude cannot take any of them by itself. They happen only when you approve them — and your approval covers that one action only.

There are two ways to run it. The full one, /metaxotrail:00-ship, plays all five stages. The short one, /metaxotrail:00-ship-lite, is for small, low-risk changes: it plays only the first three, so it has no testing stages.

When the run is finished, each part of the plan is a commit in your project (a saved version of the project), with the documents that explain why it was built that way. Nothing is pushed, that is, nothing is sent to an online copy such as GitHub: you review the commits and push them yourself.

What leaves your machine. The plugin's own code sends nothing over the network. Claude Code works as it always does: what you write, and what Claude reads in your project, go to Anthropic's model, and Claude searches the web while it studies and plans.

Limits and cost

  • The score shows that the process was followed, not that the software is correct. Whether the result is right depends on the plan, shaped by the answers you gave, and on the model doing the work. A stronger model usually gives better results.
  • The reviewer is an AI, not a person. It is a fresh Claude agent, usually the same model as the one building, so it gives a real second look but can miss the same things the builder missed.
  • It costs more than asking Claude to "make this feature". Doing the work properly — studying the code, planning, building, testing, and having every step reviewed, again after every fix — takes longer and uses more of your Claude usage. The plugin is free, but you need your own Claude plan, and the runs use it.
  • Its guards have limits. The guards that block forbidden file changes and risky commands read the commands Claude runs, so a command hidden inside another program can slip past them. It is tested on macOS only. The repository's README lists every limit.
  • It works in Claude Code only, by design: its bin/ folder keeps claude.ai and Cowork from installing it — claude.ai's chat does not run its hooks, so a run there could not be guarded, and Cowork is not tested.

What you need

  • Claude Code 2.1.300 or later, and python3;
  • a project in git, with at least one commit;
  • Claude Code in auto mode (Shift+Tab until it shows "auto"), so Claude does not stop for permission at every command. Not bypassPermissions or dontAsk: in those, your clicks on Claude's questions are not read;
  • your own changes committed or stashed first, because each commit the run makes takes every file in the project, except those git is set to ignore.

It is tested with Claude Code in the terminal and in the VS Code extension.

It works with any programming language; Flutter, Python and Unity projects get extra guidance.

How the score works

This is the score from the story above, in detail.

A game gives a player one clear number to chase. I wanted the same for building software, but a single number hides too much. So the score is a row of numbers, one for each step. Each stage has two steps: the work, and its review.

Each number counts how many steps, from that one to the end, are done. On the short way, the first three stages (map, plan, implement) make six steps, and the full score is 6 5 4 3 2 1. After the first two steps, the map and its review, the score reads 2 1 0 0 0 0.

The maximum is not the same for every piece of work. The short way has three stages; the full way has all five, ten steps, and its full score is 10 9 8 7 6 5 4 3 2 1. In both, the plan can split the work into parts: the implementing on the short way, the implementing and the testing on the full way. Each part earns its share of a step.

The game does not end when the agent says it is finished. It ends when every required step is completed or accepted by you. A review step you did not accept counts only when a separate AI reviewer passes it. You accept steps when you start from notes or a plan you already have, or when the pipeline asks you and you close a step: those steps count because you say so, without a check, and the run's history marks them as not checked.

When a review finds that an earlier step was wrong, the work goes back there: the numbers built on it drop, and they rise again as the work after it is redone and reviewed; parts already finished can keep their share, as the maths below explains.

The agent's goal is not "finish this feature". Its goal is to fill the row. It is not allowed to write the numbers itself, and it cannot stop until the row is full, except to wait for your answer. That turns a model that guesses into one that follows the same process every time, and the result becomes more predictable because the process is always the same.

The same thing in maths

A run has n steps: 6 on the short way, 10 on the full way. For each step i:

  • dᵢ = 1 when step i is completed (a review step: passed with no serious problem found, by a separate AI reviewer), or accepted by you: starting from your own notes or plan, or closing it when the pipeline asks;
  • dᵢ = 0 otherwise.

The score is the vector

s = (s₁, s₂, …, sₙ)      where   sᵢ = dᵢ + dᵢ₊₁ + … + dₙ
Enter fullscreen mode Exit fullscreen mode

and the target is

t = (n, n−1, …, 2, 1)
Enter fullscreen mode Exit fullscreen mode

The run is finished exactly when s = t, which needs every dᵢ to be 1.

The formula defines the score of whole steps. Work split into parts adds one display rule: a step split into m parts, while it is under way with k of them done, shows k/m in its own place in the row, rounded to two decimals (1 of 3 shows 0.33); the numbers before it count that step only once it is whole.

Sending the work back to step r:

  • Whole steps. dᵣ stays as it was, since step r is repaired rather than started again, and the d of every step after it goes back to 0, so the numbers that counted them fall. Keeping dᵣ does not mean step r is approved as it stands: it is being repaired, and the review after it has to pass again before anything after it counts.
  • Within a part. Only that part's share is lost.
  • Back to the plan or the map. A part keeps its share only if it was fully finished and the new plan, once it passes its review, still includes it. Until then, the row still shows the old shares.

Who I am

While I don't consider myself a developer, I have managed developers for years, so I know how software gets built, step by step: what has to happen first, what has to be checked, and what goes wrong when a step is skipped.

I have also vibe coded for a long time, since it first became possible. In my free time I build educational games: some through vibe coding, some by learning to code myself, some with outside developers. It is my hobby.

There is an honest limit to what I built: it follows the steps the way I learned them. A very technical team may work in a different order, and that is fine.

Is that all?

Meta-XoT-OSS-Rail is the core engine. It builds one piece at a time, through every stage of the way you run it, and it is free. It does not plan a whole product.

I also built a full suite on top of it: it takes you from an idea to phases and tasks, and builds each one with this engine. It is a separate product. If you would like to know more, contact me.

What the name means

The name came from my own: Metaxotos S. Split into parts, it says what the plugin does.

  • Meta means "beyond": it works one layer above the agent, on how the work is done.
  • XoT comes from an idea in AI research, "Everything of Thoughts", where a separate guide steers a language model's thinking. My plugin is not that method, but it takes the same idea: here the guide is the score.
  • OSS means open-source software, under the Apache 2.0 licence.
  • Rail stands for the guardrails that keep the work on track.

How to reach me

  • Questions, the full suite, or working together: LinkedIn
  • A problem or an idea for the plugin: the repository's issues; a security problem: Report a vulnerability on its Security and quality tab

Why I wrote this

I wrote this because I kept losing evenings checking whether the agent had really finished, and I doubt I am the only one. I built the plugin for myself, and it helps me, so I decided to share it with everyone who has the same problem. If you use it, please give me your constructive feedback, here in the comments or on GitHub.

Top comments (0)