Claude Code made me faster at building the wrong things

I've been building apps for about six years, and I've always had the same problem. I'd start coding with no real plan and keep adding stuff until I got bored. Nothing ever felt finished, so nothing really shipped.

When Claude Code came along I figured that would fix it. It made it worse.

"Just one more feature" used to take a weekend. Now it takes twenty minutes, so I added a lot more of them. My apps got bigger, and none of them got any closer to done.

Speed was never the problem

Code is cheap now. Your agent will build pretty much whatever you ask, and it'll do it fast. The hard part is picking what's actually worth building, and knowing when a release is done so you can stop and ship it.

The agent can't help much with that on its own, because it doesn't know your plan. Ask it "what's next?" and it reads the repo and guesses.

A couple of weeks ago I tested how bad this actually was. I gave Claude Code a small project with 18 tasks saved in its own Tasks list, opened a fresh session and asked what was next. It never looked at the list. It read the code and came up with its own plan. When I asked it straight out what was on its task list, it said:

I don't have a task list. This conversation is new, and nothing has been assigned or queued.

The other thing that got me was the reasons. When I let it make a call on something, it explained why pretty well, in the chat. Then I opened the next session, the chat was gone, and the why went with it.

So every morning started the same way. Re-explain the project, re-explain what we decided yesterday, and hope it doesn't wander off on a side quest.

The four rules that fixed it

None of these are clever. I just didn't follow any of them for about five years.

1. Nothing gets built straight from your head. Every idea and bug goes in a backlog first, including the ones your agent suggests halfway through a task. Writing it down is what stops "ooh, I could add..." from eating the afternoon.

2. One release at a time, with a finish line. Pick the handful of tasks that make the next version worth shipping. That's the release. Anything new that comes up goes in the backlog, and when the list is done, you ship. This is the one that actually got me shipping.

3. The agent starts every session from the plan. Before it touches any code, it reads what's next and why.

4. The agent writes down what it decided, and why, on the task. The chat disappears. The task is still there tomorrow, so that's where tomorrow's session looks.

You can try all of this today with a TODO.md and a few lines in CLAUDE.md. These are the lines that took a plain TODO.md from failing my test to passing it, plus one I added to keep the agent inside the release:

This project's plan is in TODO.md. The current release is v0.3.
When asked what's next, read the open tasks under v0.3 and pick one, with a reason.
Don't start anything that isn't in v0.3. If you think of something new, add it under Backlog and carry on.
Before working on a task, mark it in progress in the file.
When you make a non-obvious choice, write the choice and the reason under the task.
When you finish, add a short summary under the task and tick it.

The catch is you have to keep it current. The release name in there goes out of date the moment you ship.

How I actually do it now

Fair warning, this is the bit where I talk about what I'm building.

I made Frostbyte last December as a simple planner for myself, because Trello, Notion and Linear all felt like I had to learn the tool before it helped me. I've planned every release of it inside itself since v1.0.0. In April I connected Claude Code to it over MCP, and that's the setup I use every day now.

A normal session looks like this. I open Claude Code and ask "what should I work on next?". It pulls the ranked list for the current release from Frostbyte (priority, what's already in progress, what users have asked for) and tells me what to pick and why.

What's Next ranks the open work in the release. The release card on the right is the finish line.

I say go. It marks the task in progress, does the work, and logs what it changed and the calls it made on the task itself. The next day a fresh session can tell me what we decided, because it's sitting on the task.

What the agent leaves on a task when it's done. Tomorrow's session reads this before it starts.

The part I didn't expect to like is user requests. People post bugs and ideas on a public board, and they land in the same backlog as everything else, so they go through the same rules. A user sent me a few recently, and they went out in the next release with everything else.

It's free to try, agent connection included. In Claude Code it's two commands:

/plugin marketplace add Sky-Enterprises/frostbyte-plugin
/plugin install frostbyte@frostbyte-plugin

Paste your token from Settings, then ask it what's next. If you've already got a TODO.md or a build plan, ask it to set your project up from that. It shows you the plan before it writes anything.

If it's just you and one repo, the TODO.md and those lines might honestly be all you need. Frostbyte starts earning its place once users are sending you requests, someone else joins, or you're juggling more than one project.

It's been nearly a year. I've got 86 signups and 3 paying customers, so I've clearly still got a lot to work out, and I'd really love to know where it falls over for you.

So, how do you decide?

How are you deciding what your agent builds next? Or are you just letting it pick? I'm keen to hear what's working, especially if you've found a way out of the "one more feature" loop.

I'm Thomas, a solo dev from Adelaide, Australia. Frostbyte is at getfrostbyte.dev, and the plugin is open source on GitHub.