AI Coding Guide: Retirement is here.
February 2026
I have been using Claude Code since day 0. (Actually before day 0, I set up an MCP to do what Claude Code did before they released a product for it). The type of code orchestration Anthropic has had was half a year ahead of its time. (See the video I made 32w ago on this topic). It was the only product on the market for a solid 6+ months that actually sped up engineering an additional 5-10x from the traditional AI tools. The rest of the tech world has recently caught on (both in product & investing valuations) with Codex being really the only other orchestrator that has been able to keep up. (Google apparently has Gemini Code Assist that I have not tried but is allegedly pretty good too).
The result: over the last year, AI has condensed months of software engineering work into a few days.
The next question I (and others) ask is:
How do I condense those few days into a couple hours?
.
.
.
(Then minutes?)
I feel like 99% of the world doesn't truly understand how much this is affecting our world. Even some software engineers that are out of the loop are just now waking up to Claude Code / Codex over poorer options like Cursor or Windsurf. *cough* META engineers *cough*.
But it takes time for adoption to spread, because a couple pioneers need to create their optimal systems, and then have those systems adopted by others as the "standard". Even when the standard is set, people love to debate, and it takes weeks or months for them to even attempt a new standard and get up to speed. This is assuming there's even a product for it. As I mentioned, I was already iterating with my own ghetto version of "Claude Code" before it was even released.
However, I think that exact type of iteration will be what sets engineers apart in the next 1-5y.
Until we are all self-employed.
I believe I am currently experiencing the next exponential jump. I am not joking when I say I have made over a year (or two? or three? it's hard to quantify accurately anymore) of traditional software progress in just 2 months.
Thesis
With the rise of execution becoming exponential, we're hitting a point where planning and human understanding are becoming a bottleneck. There are so many things I know I need to do for my project / product, but the rate at which execution is being done (really f***ing fast), planning and understanding can seldom keep up. By the time I have learned and planned something I'm basically halfway done with execution. Not only that, from most engineers I know, I am constantly hearing "AI came up with a solution much better than what I could have in a fraction of the time." So if I ended up doing the bulk of the planning myself without running it against another brain (artificial or meat) it probably wouldn't even be that good.
Despite AI-driven development being exciting, cutting edge and fast, it makes a ton of mistakes. It still takes quite a long time for more ambitious projects due to the nature of those mistakes. But prompting & prompting-organization have gotten so good (Claude superpowers), that we are now hitting the tipping point where the developer has become a bottleneck instead of an enabler.
Right now the efficient, standard, AI dev process looks something like this:
- I come up with an idea / have a project to solve
- I plan out in my head, and/or an ERD/PRD (Engineering/product requirement doc) what needs to happen
- I break it down into parts
- I ask AI to solve these parts one by one, or I simply explain each piece out in a long-winded task list (and pray that AI doesn't screw it up)
- Review, and go down the list
- Repeat 3-5 every 10-30 minutes for 8h a day
- Debug debug debug
Often though, you know what the issues are when they come up. They are pretty obvious and repeatable throughout different projects when doing code review. There's so much context AI needs to have for execution that it will inevitably mess up if it is missing or misunderstanding a piece of implementation, which, if not caught early, can cascade into a ton of deeper issues down the line. Often (if you're a semi-decent engineer) you will know where these major decision issues will be, and offer a bit more care to address them.
However, if you knew exactly what mistakes could happen, and what your response should be for the next 100 iterations (you knew the questions it was going to ask you ahead of time, and you know what would be broken by AI ahead of time) you wouldn't need to sit at the table and review everything that's been output for hours.
The goal: remove the developer from the process as much as possible by front-loading and back-loading the prompting with the tools accessible (which will only get better). The developer is still needed, but we want to be mindful of the developer's time and only require the developer on a need-to-know basis and need-to-execute basis. This becomes easy by essentially only involving the developer at the beginning & end of the dev process.
This turns my 8h day of 10-30m intervals into 2-3 hour sessions over the course of a week, with 80+% of the time being used on implementation by the AI.
But you have to be comfortable living in the dark. This is the first time AI knows the code better than I do, instead of the other way around (me teaching AI what it needs to know to execute correctly).
With that said, here we go.
What I believe is currently the fastest form of development
First, some short-term trade-offs (since this is not standard yet).
Positives:
- At least 5-10x faster than regular AI-driven development
- Does not require full understanding of implementation up front (can use cutting-edge tech without first learning about it)
- Lowers intelligence barrier-to-entry
- Allows you to implement more-elegant solutions than what you could have come up with on your own
- Less friction from idea → valid/smart/correct implementation
Negatives:
- Large gaps in implementation knowledge
- Hedged by the auditing step
- With larger projects, AI is much less likely to connect all the pieces
- Hedged by the auditing step
- Deprecated code is more dangerous and becomes more annoying to find and manage
- Hedged by the auditing step
- It is slightly uncomfortable to let AI take the responsibility of thinking & organization instead of you
- Hedged by Religion and Prayer
Note: long-term, when the world catches up, and there's billions (trillions?) of dollars behind this type of workflow, the negatives will be solved through more intensive worktrees than what I as a single individual have created below. I am building a company, and unfortunately don't have the time to solve all of the problems I've seen (see Notes section below), but they are all 100% "easily" solvable.
Workflow
Step 1: Product Design 3 hours – 1 week
- Use your favorite LLM chat (I use ChatGPT) to solidify what you want from your product, including research, understanding, engineering implementations at high levels, edge cases, issues, etc. (Product can be huge. The goal is to understand what it does and how it works at a HIGH level. Whatever you want, no limits. Actually try to stress test it. Seriously.)
- Note: False or incorrect assumptions here can be costly but not existential. Everyone has their own product designing phase and there's plenty of material on this already so I won't go into detail here, but the end goal of this step is to really, really, really know what you want, because we are extremely close to true one-shotting large, complex projects. That is why this timeline is so generous.
Step 2: Engineering Design 2 hours
- Ask chat to summarize everything into a PRD with engineering specifics (no data-models). Ensure that it has implementation details for each step of the pipeline on how to implement
- Paste the PRD into a new context window. This window is now your "Project Manager", not you.
- Open Claude and run
/superpowers:brainstorm - Paste in your PRD
- Claude will ask you various questions about implementation
- Don't answer them! (unless you want to)
- Paste the questions to your ChatGPT Project Manager and get the answers
- Paste the response back to Claude
- Repeat until finished.
- Claude will generate a design document. Review the document (optional). Paste this doc into your project manager and ask it to review. Paste the response back into Claude 1-2 more times until solid.
Step 3: Implementation Design 10 minutes
- Clear context in Claude Code
- Ask Claude to write the implementation doc for the design doc it created (
/superpowers:write-plan) - Note: If your design is ESPECIALLY big, you may ask it / it may ask you to implement MULTIPLE implementation docs (I have had one design doc create 4 separate implementation docs, each with 30+ tasks.)
Step 4: AI Coding 1–24 hours waiting
- When complete, close Claude, re-open with
--dangerously-skip-permissionsflag - Ask it to execute superpowers for the first implementation doc
- Sit back and relax until complete
- Repeat step 4 for as many implementation docs as you have
- Each doc will take anywhere from a few hours to a few days depending on how large your project is
Note: if you somehow realize you completely screwed up your PRD from the beginning (like I did), this is a good time to double / triple check that all of the assumptions you made are correct. Really you should have done this at the PRD stage, but at most, at this point you've only lost a few hours and a day or two of credits. If you realize the implementation you chose is not correct, repeat steps 1-4 using the design doc you created as an initial reference point.
Step 5: Code Audit 1–3 days
With any worthwhile or ambitious project, you need to make sure it actually worked. Claude will mess up connections between implementations (naturally — the context is WAY too large) and therefore it is imperative that you have a MEDIUM level understanding of the code (need not understand line by line, but you need to know what each function / step should be doing during execution).
- Ask Claude to explain to you how everything works, referencing implementation docs
- Ask Claude to create a workflow tree with relevant endpoints
- Run the pipeline / code / execution end to end manually once
- During this phase you may find bugs, solve them as you normally would with Claude
- When the bugs are fixed and the tree is created, now get granular and ask Claude to review each step one by one (traditional AI + human debugging. ex: "review step one in this pipeline")
- By the end of this process you should have a much more solid understanding on what the hell AI actually did
- Create end-to-end tests for ensuring that the OUTCOME of the code gives you exactly what you want. When you understand the intricacies of the code as you walk through, have Claude create intermediate tests as well
At the end of this, you should have a working system in 1/100th of the time it would take with traditional engineering. At least a 10x gain from AI-enabled engineering. The reason for this is that debugging a correctly structured high-level implementation (this 5 step workflow) is much faster than building each piece of the structure to completion (current dev flow).
Think of it like building a house. It's a lot easier to build when all of the high-level skeleton is made. It's not necessarily complete — but you know where the walls are, which room is where. You just need to connect the pieces on the inside.

Give it a try. I was able to code something I didn't even fully understand until a month later. For the first time my understanding of the code was not a bottleneck to making progress. This has never been possible before in the history of engineering. Progress used to move as fast as the smartest person's understanding moved. Now it can take a few leaps ahead and allow you to build code + understanding at the same time. You just have to be comfortable letting go of the wheel a little bit more.
The reason this all works is because when you need to fix something, you can. It's similar to working on a codebase in a company. You don't need to understand the entire code, just the piece you are currently working on / fixing. And in many cases you don't really need to know how it works, just what the inputs and outputs are and where they feed to/from.
And trust me, you better get used to it, because it's only going to get more automated from here. I put the next steps to make it even more automatic (see NOTE below). You can even do it yourself if you're motivated enough to be a pioneer. Maybe you can be the next superpowers open source tool.
This is already long enough. But it's actually insane to me how quickly this is all changing. And just to make things even more enjoyable, as of 5 f***ing hours ago you can now run this entire workflow at the gym, at a party, on a walk. All of this can be done without even being at the computer.

Insane. The above screenshot deserves its own post. This is fresh off the press and I can't wait to work from the gym.
Ciao, I'll see y'all on the moon.
Maxwell
Notes
- Automating the PM → Claude connection is an easy next step. It's what truly makes this an idea → code ready workflow. I actually think this can be done today.
- I believe there is a world where the code-auditing step can also be automated away soon. The only real requirement is to create workflows ahead of time to test in production. It's a big build. It will require some intentional implementation there. This will be by far the biggest time unlock.
- Following that there would need to be some sort of orchestration for true black-box, end-to-end development testing to ensure what has been built truly works as intended. This is largely the biggest mountain, and is exponentially harder for a front-end implementation.
- Following that, we can then automate the PRD step. Build structure to help AI find the most optimal way to solve a problem and simply prompt the user on specifics on what they mean and to extract the context from the mind. This is the turning point where we focus less on optimizing workflow and more on extracting information from the developer.
- Following that, we start to go truly exponential. We automate ideas. This is where projects do not even need to be thought of before they are fully implemented. This is when the big AI giants begin building spin-off companies. This is what I am betting myself and my career on in the next decade.