<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
<channel>
  <title>Martin Štěpánek</title>
  <link>https://martinstepanek.github.io/</link>
  <description>CTO at Maxfusion AI · Full Stack Web Developer</description>
  <language>en</language>
  <lastBuildDate>Wed, 18 Nov 2026 12:00:00 +0000</lastBuildDate>
  <image><url>https://martinstepanek.github.io/avatar-192.webp</url><title>Martin Štěpánek</title><link>https://martinstepanek.github.io/</link></image>
  <atom:link href="https://martinstepanek.github.io/feed.xml" rel="self" type="application/rss+xml" />
  <item>
    <title>Onboard your agent like a new developer. How we wrote our CLAUDE.md</title>
    <link>https://martinstepanek.github.io/onboard-your-agent-like-a-new-developer/</link>
    <guid isPermaLink="true">https://martinstepanek.github.io/onboard-your-agent-like-a-new-developer/</guid>
    <dc:creator>Martin Štěpánek</dc:creator>
    <pubDate>Wed, 18 Nov 2026 12:00:00 +0000</pubDate>
    <description>Don&#x27;t copy someone else&#x27;s CLAUDE.md. It was written for their codebase and their team. Your codebase looks different and your team works differently, so your agent has to work differently too.</description>
    <content:encoded><![CDATA[<p>Don't copy someone else's CLAUDE.md. It was written for their codebase and their team. Your codebase looks different and your team works differently, so your agent has to work differently too.</p>
<p>In my previous article, <a href="https://martinstepanek.github.io/make-the-wrong-code-impossible/">Make the wrong code impossible. How we set up our codebase for agents</a>, I wrote about where to fix the things your agent keeps doing wrong. First in the codebase, then with deterministic checks like CI, and only after that in prose: CLAUDE.md or skills. This article is about the prose.</p>
<p>Think of the agent as a new developer on your team. At the start he doesn't understand anything about how you work. He needs to be onboarded, so he understands your intent and behaves the way the rest of the team expects. That is what CLAUDE.md is for: aligning the agent with you and your team. And with an agent, every session is his first day.</p>
<p>I won't give you a template. I will show you what is in ours and why, so you can think about what should be in yours. And also what should never be there.</p>
<h2 id="what-should-not-be-there">What should not be there</h2>
<p>First, never use Claude Code's /init command, which creates a CLAUDE.md for you. By design, /init is wrong, because it creates it from the codebase. That means it writes down everything the agent is already able to read by himself. But CLAUDE.md should contain only the things he is not able to read or infer from the codebase. So I highly recommend writing it by hand and not letting AI write it.</p>
<p>For the same reason, it should never contain a description of the codebase. No documentation or path explanations (a lot of people write something like "src/ - code, docs/ - documentation", explaining what is where). This kind of documentation becomes obsolete very quickly, so it might even cause harm. And if the agent can't find his way around the code, fix the code.</p>
<p>And it should not contain anything that can be checked deterministically by a script. For example, we use React Compiler, so there is no need for manual useMemo or useCallback. That rule had been in our CLAUDE.md since April, but the agent kept adding them anyway. So we added a linter rule that fails on every new one, and removed the line from CLAUDE.md. Now the agent can't get it wrong.</p>
<h2 id="your-values">Your values</h2>
<p>Write down what you value. These are decisions you made as a team, and the agent can't see them in the code.</p>
<p>For example, we don't really care about backward compatibility, since most of our traffic comes from MCP and not from the API. And the agents using our MCP have no problem with breaking changes. They just pick up the newest tools. But agents tend to write special shims so they don't introduce a breaking change, even when it's not worth it. That makes the code way more complex.</p>
<p>What we value is simplicity. The simpler the code is, the easier it is to read, update and remove. And the fewer errors it has. So our CLAUDE.md says that on our public API and MCP, simplicity beats backward compatibility. Delete the old behavior instead of keeping shims and dual code paths for it.</p>
<p>The second one: we value deploys that don't interrupt work. We deploy often, so our services restart often. For the user, a restart has to be a non-event. A generation that was running has to finish after the restart. It can't fail, hang or charge the user twice. So every feature has to be designed with that in mind.</p>
<p>To find your values, look at the PRs where the agent made a decision you would have made differently. Usually there is a reason why you would do it differently, and that reason is what you write down.</p>
<h2 id="your-language">Your language</h2>
<p>Every product has its own language, and it can't always be understood from the codebase.</p>
<p>We have surfaces: places where our users can use our features. Studio, flows, our public API, MCP and our in-app agent. We use these words in our specs and prompts all the time, like "ship it on every surface". So our CLAUDE.md has a short definition of each one, together with a rule: every new feature ships on all surfaces, and they all share one core, so it behaves the same everywhere.</p>
<p>A lot of engineers now embrace domain-driven design (DDD) even more than in the past, since it gives the agent a clear separation and a common vocabulary to communicate with. DDD has its own downsides, so we are still looking into it and haven't applied it yet.</p>
<p>Write down the words from your specs, issues and prompts that the agent can't learn from the code.</p>
<h2 id="behavior">Behavior</h2>
<p>Tell the agent how to behave: how to work with you, how to approach things, when to be autonomous and when to stop for your input. These are some examples we have in our CLAUDE.md.</p>
<h3 id="which-model-does-what">Which model does what</h3>
<p>We use different models for different work, and our CLAUDE.md says which one is for what. At the time of writing this article, Opus 5.5 is the default for almost everything: implementation, plans, specs and investigations. We use Fable 5.2 only when we ask for it.</p>
<p>Every piece of work gets two independent reviews before it's handed over: one from a fresh Opus 5.5 that did not write it, and one from GPT Sol 6.1. We don't trust Sol to ship code as much as Opus. But Sol is incredible at reviews, since it's very diligent. It also helps as a second thinker on hard problems, because it brings its own view.</p>
<p>In the first article of this series, <a href="https://martinstepanek.github.io/start-small-then-let-go/">Start small, then let go. How to learn to trust AI agents</a>, I recommended telling the agent to use a different model to review his PR. With this in your CLAUDE.md, you don't have to tell him every time.</p>
<h3 id="investigations-and-questions-are-read-only">Investigations and questions are read-only</h3>
<p>Models tend to jump to implementation, even when you don't want them to. You just ask why something is broken, and the agent is already fixing it.</p>
<p>That's why the most useful lines in our CLAUDE.md are probably these: investigations are strictly read-only. The agent reads the data and reports what he found, but he changes nothing unless we tell him to.</p>
<p>What he can look at, like errors, logs, metrics and a copy of our production database, is listed in a separate investigate skill.</p>
<h2 id="keep-it-up-to-date">Keep it up to date</h2>
<p>Your CLAUDE.md is not something you write once.</p>
<p>Update it at least with every new frontier model. Different models behave differently. They have their own quirks, strengths and weaknesses. Our model section has changed with every release since July. Back then, the models were so different that we had a table with a score for every model's cost, intelligence and taste. Now Opus 5.5 is extremely good at almost everything and GPT models are great for reviews, so a few simple lines are enough.</p>
<p>It also needs to be checked against your previous conversations and updated based on them. Every time you have to step in and correct the agent, there is a reason for it. You don't have to look for it by hand. Just ask the agent: "go through my last sessions, find every time I had to correct you, and tell me why".</p>
<p>If something keeps coming back, it's a candidate for CLAUDE.md. But first try to fix it in the code or with a check, as I wrote in the previous article. Only if that's not possible does it go into CLAUDE.md. The agent reads the whole file in every session, and every line competes for his attention with all the others, so try to keep it short and simple.</p>
<h2 id="write-your-own">Write your own</h2>
<p>So when you are writing yours, ask yourself three questions. What do you value when you build your software? Which words are specific to your product and don't clearly map to your code? And when did the agent behave in a way you didn't want, and how would you like him to behave instead?</p>
<p>Next article: scaling. What happens when you run tens of agents at once, and why the bottleneck moves from writing code to everything around it.</p>
<p>What is the best line you ever put in your CLAUDE.md?</p>]]></content:encoded>
  </item>
  <item>
    <title>Make the wrong code impossible. How we set up our codebase for agents</title>
    <link>https://martinstepanek.github.io/make-the-wrong-code-impossible/</link>
    <guid isPermaLink="true">https://martinstepanek.github.io/make-the-wrong-code-impossible/</guid>
    <dc:creator>Martin Štěpánek</dc:creator>
    <pubDate>Tue, 10 Nov 2026 12:00:00 +0000</pubDate>
    <description>Your agent copies your codebase. Give him a mess, and he will write more mess. Give him a clear pattern, and he will follow it.</description>
    <content:encoded><![CDATA[<p>Your agent copies your codebase. Give him a mess, and he will write more mess. Give him a clear pattern, and he will follow it.</p>
<p>And the code he writes is not for you. It is for the next agent, who will copy it again. Agents are the first-class citizens in your codebase now, not you.</p>
<p>In my previous article, <a href="https://martinstepanek.github.io/start-small-then-let-go/">Start small, then let go. How to learn to trust AI agents</a>, I wrote about how to start trusting your agents. I ended it with this: how far you can let go depends on the codebase too. What the agent can learn from it, what it checks for him, and how many agents can work in it at once. This article is about the first two. How many agents can work in it at once gets its own article.</p>
<h2 id="fix-it-in-the-code-first">Fix it in the code first</h2>
<p>Every time you find something bad in a PR, fix it in the PR. And then try to fix it structurally, so it won't happen again and you don't have to steer the agent again in the future. To find what to fix, ask the agent why he did it. Most of the time he copied an old pattern or followed a stale line in your docs, and that is what you fix.</p>
<p>I was doing this myself, but I did not know how to put it into words. Then I found <a href="https://x.com/poteto/status/2111133080526495985">a post from Lauren Tan (@poteto)</a> and could not describe it better. So I borrowed her explanation.</p>
<p>Fix it as high in the pyramid below as you can. First the codebase. Then static analysis: lints, types, tests and CI. Then verification, like the agent testing his own work. Only after that prose: your CLAUDE.md, AGENTS.md or skills. And human review comes last.</p>
<figure><img src="https://martinstepanek.github.io/images/make-the-wrong-code-impossible/01-trust-pyramid-poteto-689.webp" width="689" height="441" alt="Lauren Tan&#x27;s inverted pyramid: codebase (good API design, architecture, refactoring), static analysis (lints, types, compilers, tests, CI), verification (formal, empirical), prose (rules, skills, AGENTS.md), human review" loading="lazy" decoding="async" /><figcaption>Most of the effort goes at the top, the least at the bottom. Image: <a href="https://x.com/poteto/status/2111133080526495985">Lauren Tan (@poteto)</a>.</figcaption></figure>
<p>Start at the top. The codebase has to be written so that the agent is not likely to implement something badly.</p>
<p>Some patterns are also more friendly to agents than they would be to humans. Matt Pocock is <a href="https://x.com/mattpocockuk/status/2115442777647726835">debating banning useState</a> in React apps entirely. It limits what state the app can be in, and with fewer ways to do something, the agent writes good code more often.</p>
<p>When the codebase can't prevent a mistake, add deterministic checks that constrain the agent: more on those in the next section. And only when that is not fully possible, update your prose so it guides the agent the way you want.</p>
<p>The codebase always beats comments and documentation. Documentation and comments can quickly become stale and guide agents in the wrong direction. The codebase should always be the source of truth. Lauren goes as far as banning almost all comments. I am not sure about that and haven't done it yet, because I like having additional context around the code. But it might be a good move.</p>
<h2 id="ci-gates">CI gates</h2>
<p>CI gates are deterministic checks that run on every PR. They either pass or fail. Ideally they are also fast and cheap: simple scripts and fast linters, not e2e tests.</p>
<p>The cheapest gates are the ones you probably already have: types and linters. Ours run TypeScript in strict mode and a linter for every language we use, on every PR. The custom checks come on top of them.</p>
<p>Here are a few of those custom ones, to give you a picture of what I mean. We would probably never have added checks like these before AI took over. But today you can one-shot each of them with a single prompt, so it's easy to add one whenever you need it.</p>
<h3 id="use-the-components-we-have">Use the components we have</h3>
<p>We have a design system with its own components, and the agent has to use them. Not create his own buttons. So CI fails any PR with a raw button: use Button or IconButton. The same goes for inputs and tooltips. The Button also owns its height and radius, so the agent cannot restyle it where he uses it. And colors are tokens, so a hex color anywhere outside one file fails too.</p>
<h3 id="money-goes-through-one-place">Money goes through one place</h3>
<p>Every write to the tables that hold our customers' credits goes through one module. CI fails any PR that writes there from anywhere else.</p>
<p>We added the gate the same day as the module, before anything went wrong. You don't need an incident to add a gate. If a mistake would be expensive, make it impossible from the start.</p>
<h3 id="one-helper-one-place">One helper, one place</h3>
<p>In October I asked the agent to clean up our small helpers: formatting dates, the right timezone, formatting names and so on. They were duplicated a lot: hundreds of copies, each written slightly differently, and some of the differences were bugs. One wrote local time into a column that should be UTC.</p>
<p>Some of the copies were written by people, some by agents. And the agent copies whatever is there. So first every helper got one place in the codebase, every copy was replaced with it, and the helpers nobody used were deleted. Then we added a gate, so the copies don't grow back. A new private copy fails CI unless it is listed with a reason.</p>
<p>That is the order from the first section. Fix the codebase first, then add the gate.</p>
<h3 id="you-don-t-have-to-fix-everything-first">You don't have to fix everything first</h3>
<p>Some of our gates started on code that already broke the rule in many places. So the gate starts with a list of every old violation. Those pass, anything new fails, and the list can only get shorter. The codebase never gets worse, and the old violations get fixed over time.</p>
<h2 id="tests">Tests</h2>
<p>We have automated tests only for billing. Honestly, I am not a big fan of them at our stage. Everything else the agent tests the same way you would, once, before he opens the PR. I wrote about that in the previous article.</p>
<p>For some teams this might not be optimal, and they might want to cover way more. That is fine. But tests have a maintenance cost. Every test you add is one more thing to keep up to date with every change. That got cheaper with AI too, but it's still not zero.</p>
<p>And right now, no automated test can beat human QA. Agents are not yet good at recognizing bad UX, or whether a feature makes sense the way it's implemented.</p>
<h2 id="prose-claude-md-agents-md-and-skills">Prose: CLAUDE.md, AGENTS.md and skills</h2>
<p>When your agent keeps doing something you don't like, and it's hard to enforce with any of the above, then you mention it in your CLAUDE.md, AGENTS.md or skills.</p>
<h2 id="human-review-the-pr-template">Human review: The PR template</h2>
<p>In the previous article I mentioned the PR template. The goal is to unify all PRs, so they are easier to review once you get used to the structure.</p>
<p>Ours goes like this. The problem: why this PR exists. The solution: what changed, for someone who has not opened the diff. Verification: how the agent tested it, with before and after screenshots, and possibly a video. And operator steps, when someone has to do something by hand on deploy, like setting a new environment variable.</p>
<p>To make the solution easier to understand, I recommend the <a href="https://github.com/humanlayer/skills/blob/main/plugins/show-me/skills/show-me/SKILL.md">show-me skill</a>. It helps the agent visualize and explain the change: a diagram, a sketch of the call tree or a diff of the file structure instead of a wall of text.</p>
<p>Right now I am also experimenting with an impact rating. The agent rates three things low, medium or high. Blast radius: how much of the app the change can break, from one screen to the whole platform. Revertibility: how easy it is to undo, from a simple revert to a database change that needs a manual fix. Production impact: what it changes for users, and whether it touches money, login or deploys. The PR gets the worst of the three.</p>
<p>The agent doesn't start from zero. A script reads the changed files and sets the lowest level each axis can get. Change a file that handles money, and production impact is high, whatever the agent thinks. The agent can raise a level, never lower it. And he has to back every level with evidence, not adjectives.</p>
<p>The goal of a PR description is to answer all the questions the reviewer might have, before he has them. So don't copy ours. Think about what you read first when you open a PR, and put that at the top.</p>
<h2 id="next-how-to-write-your-claude-md-or-agents-md">Next: how to write your CLAUDE.md or AGENTS.md</h2>
<p>Prose is for what the agent cannot learn from the code and no script can check for him. How to write it is the topic of the next article. Not ours to copy, but how to think about what belongs in it and what does not.</p>
<p>Which mistake does your agent keep repeating?</p>]]></content:encoded>
  </item>
  <item>
    <title>Start small, then let go. How to learn to trust AI agents</title>
    <link>https://martinstepanek.github.io/start-small-then-let-go/</link>
    <guid isPermaLink="true">https://martinstepanek.github.io/start-small-then-let-go/</guid>
    <dc:creator>Martin Štěpánek</dc:creator>
    <pubDate>Fri, 06 Nov 2026 12:00:00 +0000</pubDate>
    <description>The code does not have to be perfect. It never was.</description>
    <content:encoded><![CDATA[<p>The code does not have to be perfect. It never was.</p>
<p>It took me a while to accept that. A bit more than a year ago, I was one of those resistant engineers who refused to use AI for coding. When I finally started, it took me about a month on Opus 4.5 to get to a level that was the same as before.</p>
<p>In my previous article, <a href="https://martinstepanek.github.io/ai-writes-100-percent-of-our-code/">AI writes 100% of our code. Here is what happened.</a>, I showed how we use AI to accelerate our development and what impact it had on our codebase and platform. What I did not show is how we achieved it. That is too much for one article, so I will cover it over several, starting with the basics: how to start trusting your agents to write code.</p>
<p>This article is for two groups of people. Those who still write some code by hand, and those who let AI write all of it, but still watch the thread as it works and actively steer it. There is one section for each.</p>
<p>One assumption for both: you work on feature branches and merge them into a protected dev branch through pull requests. And the agent is sandboxed or limited, so he cannot touch anything he could break, like production. Then he can do whatever he wants on his branch without you approving every step. The goal is to give him as much autonomy as possible without him being able to do any harm.</p>
<h2 id="still-writing-code-by-hand">Still writing code by hand</h2>
<h3 id="model-selection">Model selection</h3>
<p>At the time of writing, I would recommend most people get an Anthropic subscription and use Opus 5.5 on high effort for most tasks. For simple tasks you can use lower effort, and of course it's OK to use GPT models as well. This is just my general recommendation. Opus 5.5 is an almost Fable-level model, while being way cheaper and more economical with your subscription usage. Why I think Fable is so good is in <a href="https://x.com/st3pan3k/status/2118311481955463507">my post about which models changed how I work</a>.</p>
<h3 id="aligning-intent">Aligning intent</h3>
<p>Your job is not to tell the agent exactly what to do. Your job is to explain the problem you are trying to solve and give the agent all the data he needs. Today's models will probably solve it better than you (no offense).</p>
<p>So when you are starting, make sure the agent understands your problem. Explain your problem and your goal. Let the agent create a plan first. The reason for the plan is to make sure the agent thinks the problem through and gets all the data before he starts working. If you just tell him to build it or fix it, he will start working and then, in the middle of the work, realize he did not think of something.</p>
<p>Claude Code no longer starts in plan mode, and the team behind it is thinking about removing it altogether. Models today do not need a special mode. You can just tell them to plan before they start working.</p>
<h3 id="don-t-try-to-one-shot-at-the-start">Don't try to one-shot at the start</h3>
<p>A lot of developers immediately try to one-shot a solution, get bad results and give up with "AI generates slop". Or they try to debug and polish it, which takes them even more time than writing it themselves, and conclude the same.</p>
<p>To be able to one-shot solutions, or almost one-shot them, you have to understand how to prompt which model (different models need different prompting styles) and what AI is good at and what not, and you have to have a system set up for review and verification.</p>
<p>What worked for me is to start small. I told the agent to implement a simple method. From there multiple methods, classes, integrations and whole features, slowly increasing complexity and trying to find out where the boundaries are, what works and what doesn't. It takes time and patience. Unfortunately there is no better recipe than that.</p>
<h3 id="controlling-git">Controlling git</h3>
<p>At the start, just review the changes and commit them yourself. The moment you are satisfied with the changes, let the agent commit for you! I promise he will write way better commit messages and descriptions than you. And while you are at it, let him also create the pull request for you. You might want to create a PR template the agent follows, but more about that in the next article.</p>
<h2 id="still-watching-the-thread">Still watching the thread</h2>
<p>You are not useful when you are watching AI work. You want to get to the point where you kick off the agent, let him work and don't hear from him until he is done. And when he is done, you just check the PR and merge it. Ideally, you maximize the chance that you actually want to merge the PR. That the PR is right. And while he is working, you are free to do other things, for example kick off another task in parallel.</p>
<p>In 40 days I <a href="https://x.com/st3pan3k/status/2114308289152291051">shipped 1,200 PRs</a> and had to intervene in only 11.5% of them (steer the agent or cancel the PR). I would not be able to do that if I was watching the threads.</p>
<p>Don't forget that PRs and code are cheap. If you don't like one, you can always tell the agent to rebuild it or throw it away.</p>
<h3 id="code-review">Code review</h3>
<p>Before you get to code review, let the agent review the code for you and fix the issues. And no, he probably won't do it by himself without you telling him. So when you instruct the agent to do something, just append to the end of the prompt: "when you create the PR, do a code review and fix the issues". Simple as that. No skills, and I promise you, the output will be significantly better.</p>
<p>If you have multiple subscriptions, I recommend telling one agent to use a different model to review his output. It has a different view of the code, the same way different people have different views. Tell Opus to use GPT Sol 6.1 to review his PR.</p>
<h3 id="testing-and-verification">Testing and verification</h3>
<p>The more the agent is able to test his work, the better his output will be and the more you can trust him. Frontier models already try to verify their work, but ideally you want to tell them explicitly to do it, and how.</p>
<p>And no, it's not about writing automated tests. Of course you can. But the agent can just test it once, the same way you would. Try telling your agent to e2e test your feature. If it's backend, he can call all the endpoints and verify all the cases. If it's frontend, he can click through the UI and test it as a normal person would.</p>
<p>Want to be sure the agent tested it right? Tell him to include screenshots or even videos in the PR. Today's models are more than able to do that. Every time I open a PR with visual changes, it contains before and after screenshots of the app.</p>
<h3 id="letting-go">Letting go</h3>
<p>And this is probably the hardest part. The code does not have to be perfect. It never was. Just because the agent does not write code the way you do does not mean it's not worth merging. Maybe he writes more verbose code than the average human. Why care?</p>
<p>Code always has to fulfill two requirements. It has to do what's expected of it, and it has to be readable. The moment you look at the code and realize you don't understand it the way you want to, fine, refactor it. But until then, you don't have to care about every line break, constant or method name. I wrote more about this in June: <a href="https://x.com/st3pan3k/status/2112939707881390560">Code quality just does not matter that much anymore</a>.</p>
<h2 id="next-the-codebase">Next: the codebase</h2>
<p>Everything above works in any codebase. But how far you can let go depends on the codebase too. What the agent can learn from it, what it checks for him, and how many agents can work in it at once without getting in each other's way. In the next article: how we set up ours.</p>
<p>What still makes you watch the thread?</p>]]></content:encoded>
  </item>
  <item>
    <title>AI writes 100% of our code. Here is what happened.</title>
    <link>https://martinstepanek.github.io/ai-writes-100-percent-of-our-code/</link>
    <guid isPermaLink="true">https://martinstepanek.github.io/ai-writes-100-percent-of-our-code/</guid>
    <dc:creator>Martin Štěpánek</dc:creator>
    <pubDate>Tue, 13 Oct 2026 12:00:00 +0000</pubDate>
    <description>I joined Maxfusion AI as CTO in May 2026. Now AI writes all of our code without exception. We ship features that take others weeks or even months in days, while drastically lowering technical debt, cutting down on errors and making the platform more stable than ever.</description>
    <content:encoded><![CDATA[<p>I joined Maxfusion AI as CTO in May 2026. Now AI writes all of our code without exception. We ship features that take others weeks or even months in days, while drastically lowering technical debt, cutting down on errors and making the platform more stable than ever. And every month is better than the one before.</p>
<h2 id="8x-the-code-with-2-developers">8x the code with 2 developers</h2>
<p>In September alone we launched <a href="https://x.com/MaxfusionAI/status/2104904524393811982">Research Lab</a>, <a href="https://x.com/MaxfusionAI/status/2107422093914820804">Radar</a> and a full redesign of the platform's UI. On top of that 5 new tools, support for 7 new models, Brain with brand kits and an Asana integration, all of it on the web app, the flow canvas, the public API and MCP at once. Two engineers, one month. And it was not the first month like that.</p>
<p>On 2 July I posted that we built a <a href="https://www.linkedin.com/posts/martin-st3pan3k_my-team-was-able-to-develop-a-public-rest-share-7478409359287439360-0xrs/">public REST API with 40+ endpoints from a product specification to a production release in 4 days</a>. Most of it was done by one person in the first 2 days. The last 2 days were bug fixing and polishing. Authentication, two-layer rate limits, idempotency, async job delivery, interactive docs, an admin panel for API keys. Not vibe coded, peer reviewed, production ready. That API has 150 endpoints today.</p>
<p>The MCP server is generated from that API, so every endpoint we add becomes a tool an agent in Claude or ChatGPT can use. From spec to merged server took 5 working days. 90% of that went into frictionless interaction: tool interfaces, descriptions, MCP widgets. The code was the easy part. A week later we announced <a href="https://x.com/MaxfusionAI/status/2074463444452192321">MCP with 47 tools</a>.</p>
<p>In August we fully <a href="https://x.com/MaxfusionAI/status/2099453118480056388">rebuilt our queue</a> from the ground up in just 3 days. 99.8% of all generations now start in under 0.1 s, an edge over competitors where you have to either wait or pay extra for priority generations.</p>
<figure class="chart" data-chart="lines-monthly"><img src="https://martinstepanek.github.io/images/ai-writes-100-percent-of-our-code/01-lines-monthly-1760.webp" width="3000" height="1140" alt="Code lines changed per month, October 2025 to September 2026, with developer headcount" loading="lazy" decoding="async" /></figure>
<figure class="chart" data-chart="prs-monthly"><img src="https://martinstepanek.github.io/images/ai-writes-100-percent-of-our-code/02-prs-monthly-1760.webp" width="3000" height="980" alt="Merged pull requests per month, April to September 2026, with developer headcount" loading="lazy" decoding="async" /></figure>
<p>In lines of code, September was 8x the monthly average of the 7 months before I joined, 16x per developer. 2,472 commits against 240 to 460 a month before May, 803 merged pull requests against 45 in April. Headcount went from 5 to 2 in July. Per-developer output has gone up every month since.</p>
<p>Lines of code are a bad metric. They say nothing about whether anyone wants what we built, and nothing about the state of the codebase. Both next.</p>
<h2 id="9-9x-paid-usage">9.9x paid usage</h2>
<p>"More features do not make the product better." They do if you build in the right direction. Direction is measured in usage.</p>
<p>Paid generations in September were 9.9x January and about 5x April, the month before I joined. They grew every single month in between.</p>
<figure class="chart" data-chart="paid-generations-monthly"><img src="https://martinstepanek.github.io/images/ai-writes-100-percent-of-our-code/03-paid-generations-monthly-1760.webp" width="3000" height="1063" alt="Paid generations per month as a multiple of January 2026" loading="lazy" decoding="async" /></figure>
<p>The MCP from July did 38% of paid generations, almost as many as the web app at 39%. One third of everyone who paid for a generation used it at least once. MCP alone did 3.8x the paid generations of the whole product in January.</p>
<figure class="chart" data-chart="generation-surfaces"><img src="https://martinstepanek.github.io/images/ai-writes-100-percent-of-our-code/04-generation-surfaces-1760.webp" width="3000" height="1063" alt="Share of paid generations by where they were started, April to September 2026" loading="lazy" decoding="async" /></figure>
<p>A refund is issued when a paid generation fails, so if quality had slipped under that load, refunds would go up. They went the other way, from over 5% before May to 3.7% in September.</p>
<h2 id="5x-fewer-errors-per-generation">5x fewer errors per generation</h2>
<figure class="chart" data-chart="error-events-weekly"><img src="https://martinstepanek.github.io/images/ai-writes-100-percent-of-our-code/05-error-events-weekly-1760.webp" width="3000" height="1031" alt="Production error events per week, July to September 2026" loading="lazy" decoding="async" /></figure>
<p>We connected Sentry at the end of June. There is no error data from before that, because there was no Sentry. The first weeks were ugly: about 2,000 error events a week in July, one week over 3,000. Nothing in there was new. Sentry just showed us the backlog. July was the month of fixing what the months before had left behind.</p>
<p>Then it dropped: an average of 652 a week in August and 777 in September. Single weeks still jump around, the last one of September hit 1,294. Paid generations more than doubled over the same months, so per generation production now throws more than 5x fewer errors than in July.</p>
<p>Bugs in new code went the same way. 7.1 per 10,000 lines of code changed in July, 9.4 in August, 1.9 in September. September changed almost 3x the code of August with 5x fewer bugs per line. 78% of all code bugs since July are already resolved.</p>
<figure class="chart" data-chart="code-bugs-weekly"><img src="https://martinstepanek.github.io/images/ai-writes-100-percent-of-our-code/06-code-bugs-weekly-1760.webp" width="3000" height="904" alt="New code bugs per 10,000 lines of code changed per week, July to September 2026" loading="lazy" decoding="async" /></figure>
<h2 id="5x-less-technical-debt">5x less technical debt</h2>
<p>"Fast code is technical debt you pay later." We pay it now, and it got cheap. When <a href="https://x.com/st3pan3k/status/2112939707881390560">I wrote in June that code quality does not matter that much anymore</a>, half the thread read it as "we are abandoning quality". I was talking about the ROI of managing technical debt. The price of fixing, rewriting and deleting code dropped, so we do it all the time.</p>
<figure class="chart" data-chart="tech-debt"><img src="https://martinstepanek.github.io/images/ai-writes-100-percent-of-our-code/07-tech-debt-1760.webp" width="3000" height="980" alt="Minutes of technical debt per 1,000 lines of code, SonarQube, July to September 2026" loading="lazy" decoding="async" /></figure>
<figure class="chart" data-chart="duplicated-lines"><img src="https://martinstepanek.github.io/images/ai-writes-100-percent-of-our-code/08-duplicated-lines-1760.webp" width="3000" height="980" alt="Share of duplicated lines, SonarQube, July to September 2026" loading="lazy" decoding="async" /></figure>
<p>Around the same time we connected Sentry, we also set up SonarQube. The first scan: 593 hours of debt, 140 minutes per 1,000 lines of code, 15.9% duplicated lines. Same as with the errors, we measured it for the first time and started paying it down. By the end of September it was 28 minutes per 1,000 lines, 2.8% duplicated and about 170 hours in total, while the code grew 46%. 120 pull requests in this period deleted code and nothing else, net 80,000 lines removed. If something is too messy it is easier to rewrite it whole than to patch it forever.</p>
<p>Of course SonarQube cannot tell you everything about the state of the codebase and code quality.</p>
<p>One number went the other way. Cyclomatic complexity per 1,000 lines went up 10%, from 118 to 130. More endpoints, more tools, more branches. We care way more about cognitive complexity, SonarQube's measure of how hard code is to read, and that did not go up: flat per 1,000 lines, from 103 to 100, and 13% lower per function, from 2.5 to 2.2.</p>
<h2 id="best-month-on-every-row">Best month on every row</h2>
<p>Most code, most pull requests, highest paid usage, lowest refund share, fewest bugs per line, least debt per line, lowest duplication. And the biggest feature month we have ever had. If AI produced slop, September would be the worst month in this article. It is the best one on every row.</p>
<p>The job of a startup is to build something people pay for before the money runs out. Speed and direction are everything. The productivity gain from AI grows every month, and September was the biggest step so far. Getting there meant rebuilding the whole development cycle, the tooling, the company and everything around it. How we did that is the second article, out at the end of October.</p>
<p>What number would change your mind, if not these?</p>]]></content:encoded>
  </item>
</channel>
</rss>
