AI Company Guide: Bottom Up, Then Top Down
October 2026
Eight months later
In February I wrote AI Coding Guide: Retirement is here. At the bottom I left a Notes section with what I thought the next steps would be to make it all even more automatic. The last one said:
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 what I am betting myself and my career on in the next decade.
"In the next decade"... I genuinely thought this was years away.
It's October. Let's check the list:
- Done: Automate the PM → Claude connection (that's SSP, more below)
- Done (mostly): Automate the code audit (every piece gets reviewed and tested before it merges, and my 1–3 day audit is now a 1-hour review)
- Done: Black-box, end-to-end testing to make sure what was built actually works (for my projects, browser and all — still the biggest mountain)
- In progress: Automate the PRD (idea → strategy → product docs — this is what I'm building now)
- Not yet: Automate ideas (the idea still comes from me, for now)
The first three are all one thing: SuperSuperPowers (SSP), the layer I built on top of Superpowers. More on that below.
And that created a new problem: I finish projects faster than I can come up with them. I am spending so much of my week just sitting on my butt waiting for inspiration. Which, if you read the February post, is exactly the bottleneck I said was coming. I just didn't think it would come for me this fast. So I'm building the next layer, Goalset, to take me from an idea to the strategy and the product docs.
So this post is two things. First, a breakdown of every layer that got me here, bottom up. Second, what I'm building now, which goes the other way (top down). I'm writing it down partly so future me (and you, future reader) can see exactly where this started.
Part 0: The zoom out
Every layer here exists because the layer below it hit a wall. And the wall was always me. Each time the fix was the same: write down the thing I kept doing by hand, then hand it to the machine.
Read it from the bottom up. Each rung shrinks what the human does.
The models. Raw intelligence. A model can write a function, explain a bug, draft a plan. But it can't hold an entire project in its head, and it doesn't do anything until you ask it to. Where I stepped in: everywhere.
Claude Code. The runtime. It wraps the model in a loop that can read files, run commands, look things up and fix its own small mistakes. I've been using it since day 0 (and before that, my own ghetto MCP version of it). For a solid 6+ months it was the only thing on the market that sped engineering up another 5-10x. Where I stepped in: every 10-30 minutes, 8h a day, to tell it what's next and catch what it broke.
Superpowers. A workflow on top of Claude Code that front-loads all the questioning, research and planning before a single line of code is written. Humans show up at the beginning and at the end. That's it. Where I stepped in: answering its questions (or, let's be honest, pasting them to ChatGPT) and auditing the result.
SuperSuperPowers (SSP). My creation. It runs a bunch of Superpowers instances on one giant project, one after another and at the same time, and answers most of their questions using a written record of how I've answered them before. Where I step in: one hour up front with a mock of the finished thing, one hour of review at the end.
Goalset. The turn. Everything below it builds something you already know you want. Goalset takes an idea and figures out the strategy and what to build.
Zooming out, here's what that looked like for me, one layer at a time:
Part 1: Models & Claude Code / Codex
The bottom of the ladder is the model. Raw intelligence. It can write a function, explain a bug, draft a plan, and honestly do most of it better than me at this point. But on its own it has no hands. It answers one prompt at a time and forgets everything the second you close the window. Two years ago that meant copy-pasting code out of ChatGPT into my editor and praying it compiled.
Claude Code (and later Codex) gave it hands. It's a loop wrapped around the model: read the files, run the command, look at the error, fix it, run it again. It does lookups, it runs the tests, it solves the small stuff on its own. That's what made it the only product on the market for a solid 6+ months that sped engineering up another 5-10x. The model stopped being something I talked to and became something that actually did the work.
The unit of work here is a task. And a task is about as big as it can handle. Hand it anything bigger and it starts losing the plot: it forgets a decision it made an hour ago, misses how two pieces connect, and the mistakes cascade.
So the human ends up being the glue. In February I described the standard AI dev process like this:
- Come up with an idea
- Plan it out (in my head, or a PRD)
- Break it into parts
- Ask AI to do the parts one by one (and pray it doesn't screw it up)
- Review, go down the list
- Repeat 3-5 every 10-30 minutes for 8h a day
- Debug debug debug
Every step except 4 is me. The AI was fast. I was the bottleneck.
Part 2: Superpowers (move the human to the edges)
Superpowers is an open-source set of skills for Claude Code, and if you haven't tried it yet, stop reading and go install it. Seriously.
The big idea: most AI coding mistakes are actually planning mistakes. The AI guessed at something it should have asked about, and that guess cascaded into a ton of deeper issues down the line. So Superpowers forces the asking to happen first. Every project goes through the same steps:
- Brainstorm. Claude asks you questions, one at a time, until it actually understands what you want. It proposes 2-3 approaches and writes a design doc for you to approve.
- Write the plan. The design becomes an implementation plan of small, concrete tasks. Each one says which files, which test, and what should happen.
- Execute. Fresh subagents take the tasks one by one. Each writes a failing test first, makes it pass, and gets reviewed before the next task starts.
- Verify. Nothing is "done" until the tests have actually been run and someone (something?) has read the output.
The result is that all of the human judgment gets moved to two places: the questions at the beginning and the review at the end. The middle just runs. For hours.
How I actually used it
If you read the February post, you know my workflow. I'd hammer out the product with ChatGPT, have it write a PRD, then open a new ChatGPT window and make it the project manager. Claude would ask me a question during the brainstorm and I wouldn't answer it. I'd paste it to my ChatGPT project manager and paste the answer back.
It worked. It took my 8h days of 10-30m check-ins down to a handful of 2-3h sessions a week. But look at what I was actually doing in that loop: I was a clipboard. A very expensive, very slow clipboard. Copying questions between two AIs, and then spending 1-3 days auditing at the end, catching the same kinds of mistakes over and over.
And that was the opening. If the mistakes are predictable, and the answers are predictable, why am I the one sitting there?
Part 3: SuperSuperPowers (SSP)
Superpowers clarifies one task before it builds. SSP clarifies an entire project before it launches a bunch of tasks. It's basically a conductor: it plans and coordinates, and Superpowers does the building.
It comes down to three ideas.
1. Write down how you'd answer
This is the core of it. After a few months of running Superpowers, I noticed I was answering the same questions and fixing the same mistakes. Every. Single. Time.
So I started writing down my judgment so it could be applied without me. Almost every rule exists because something went wrong. And the best ones came from problems that didn't even exist until I had a bunch of agents working at the same time.
These days, I've tested this enough times that I let it go from start → finish without any of my oversight.
It didn't start that way. On a new project, SSP starts out with me monitoring everything. Every time it screws something up, that becomes a new rule. And every time it gets something right enough times, I give it a little more rope. Trust gets earned one rule at a time.
2. Mock first
Before anything gets built, I look at a mock of the finished product. What it looks like, what it does. And I change it as much as I want. This is the cheapest place to be wrong. Changing a mock costs minutes. Changing the real thing costs a rebuild (and a day or two of credits at the minimum, a week at worst).
3. One meeting, then it builds
SSP does all of the decision-making up front. I read the plan, approve it in one sitting, and it builds for hours without me.
The proof: I barely work anymore
I'm a founder who was doing the engineering myself to keep up with demand. That meant 12h days, 5 days a week. 60 hours at least. It was the first thing I did in the morning and the last thing I checked before bed.
Now I work 2 hours, twice a week. 4 hours. And I'm getting more done than I did at 60.
I am not joking.
Goalset (the reason I'm writing this post) is one example. SSP built the first version in one day with 350 commits, and my part was one hour of ideation and one hour of review. In February the audit at the end took me 1-3 days. Now my hour is spent asking:
"did it build the right thing?"
not
"did it build the thing right?"
Part 4: The turn (top down)
Everything up to this point has been bottom up. Start from the smallest unit (a task) and keep making it bigger. Task → project → project of projects. And after SSP, it kind of stopped mattering how big the project is. As long as you know what it should look like at the end, with a proper spec and a mock, it gets built. It might run out of usage credits eventually, but that can be solved with a few extra accounts if need be.
Which moved the bottleneck. Again. Now it's the spec itself.
I know the problems I have. What's slow is me turning a problem into a strategy, and a strategy into the right thing to build. My ability to do that is now so much slower than the ability to execute that it's almost funny.
So now I'm going the other way. Instead of taking a spec and breaking it down into tasks, I take a goal and break it down into the spec. And I mean a real-life goal (grow the business, land customers), not a development one.
Goalset: the brain of the operation
I'm aware I'm not the first person to try this. Back in 2023, BabyAGI and AutoGPT tried turning an objective into a task list and mostly got stuck in loops. Today there are idea validators that rank your riskiest assumptions, enterprise strategy tools, and well-funded startups (one raised $30M) trying to run your whole company with AI agents. But they each do half the job. The validators tell you what to test and stop there. The "AI runs your company" tools execute fast but don't validate. They'll build and market whatever they're given, whether or not anyone wants it. I haven't seen anything that does the whole loop: goal → strategy → test the assumptions → build → learn → re-plan. Which makes sense. The people who can build something this complex are devs who have been using these tools every day for the last 2 years. And most of them aren't concerned this deeply with the ideation phase yet, because they're still busy building their dev workflows. I talked to a dev friend the other day who had never even heard of Superpowers. Some devs are still using Copilot.
The idea is that you give Goalset one big goal. It keeps a living plan: what has to be true, which strategies could get there, what evidence is missing, which small projects to run next, and what only you can do. Every goal gets stress-tested: which assumptions are riskiest, which ones are cheap to test right now, and which strategy the evidence actually supports. This is basically what I am doing every day as a founder.
And then it keeps going after the plan is made, which is what makes it a brain and not a to-do list. Say the strategy for sub-goal A1 didn't account for something a customer told me. That information flows back up, and every strategy, task and piece of research that depended on it gets redone. It always knows what the options are, what the assumptions are, and what we've learned.
People have been trying to write this kind of thinking down forever (Ray Dalio's Principles being the obvious one). The difference is that now the written-down process can actually be run. As deep as it needs to go, by something that never gets tired of asking "ok but why would that be true?"
What it does vs. what I do
When Goalset decides something needs to be built, it doesn't need me to write a spec. It hands the project to SSP, SSP hands it to Superpowers, and it gets built. Before I even know what needs to be built, it's already built.
But some things AI can't do yet. Talking to customers. Getting information out of the one person who has it. Being in the right room with the right people. (Eventually it'll make the calls and send the emails too. Not yet.) So Goalset splits everything into two lists: what the machine does, and what I do. My list shows up with everything already prepared. I go do it, tell Goalset what I learned, and the whole plan updates.
And to be clear, it doesn't run without me. It never picks a strategy, spends money or contacts anyone on its own. Those decisions sit in my inbox with a recommendation and a "why is this here?" that traces all the way back to the goal. My job now is basically being an advisor to the CEO. Does this strategy make sense? Is it missing something? Is it true?
So I wake up and the strategy is already set. It's been updated overnight with whatever came in: replies from some automated outreach, or the notes I put in last night from my meetings. The software updates are already built. And I go talk to the people the system tells me to talk to.
The only human work left is judgment and relationships.
For now.
Every card on my board is a task AI can't do yet. And that list only goes in one direction. Today I'm the one sending the emails and making the calls. Soon that moves to the AI side too. Eventually it'll handle the human actions as well. Even setting the goal moves off my plate, to the next thing after Goalset: an agent that does pure idea generation. The only thing left for me is reviewing the strategy. Same pattern as every layer below it: write down what the human keeps doing, then hand it to the machine.
Part 5: Where this goes
If this works (big if, I know), three things happen.
First, my startup. I am building a company right now. Goalset should be able to tell us what to build next, where the next opportunity to grow is, and which assumptions we're betting on without even realizing it. The worst place a startup can be is in a rut, not knowing what to do next. Or, even worse, working on the wrong thing entirely. A system that always knows the next move keeps you out of it. My startup is basically my first test, and my calibrator. Because here's the catch: the higher up the stack you go, the longer it takes to validate that the system actually works, and that grows exponentially. Claude Code takes a moment to test. Superpowers takes an hour or two. SSP takes days. Goalset is going to take months.
Second, more companies. I take the proceeds from my startup and point the same system at new goals, at a rate I just couldn't before. Each company only needs a couple of people, and they don't have to be visionaries. They just have to be good at the human list: talking to customers, building relationships, reporting back what they learned. Theoretically you could hire a contractor to be the "founder," have them wake up every day, do the tasks, and feed what they learn back in. And when something we assumed turns out not to be true, the system re-plans: new strategy, new tasks, new research, everything downstream redone. At that point it's less a company and more a VC firm with a brain.
Third, the world. If it works for me, it works for anyone who builds the same scaffolding. And then it gets very crazy, very fast. When ideation is as cheap as execution, the number of companies stops being limited by people having good ideas. I could see a world where there are basically no more companies left to build.
That was honestly my fear about OpenAI and Anthropic. That they'd build this and there'd be nothing left for the rest of us. I don't think so anymore. They're working on the models, and I don't think a stronger model is going to close this gap on its own. At every rung of this ladder, what closed the gap wasn't intelligence. It was structure: a written-down record of where the model goes wrong, what to ask before acting, and where the human is actually needed. A smarter model makes each rung cheaper. It doesn't build the rungs.
In February I predicted we'd go from relying on AI for execution to relying on it for ideation. I said it would take a decade. Eight months later, I'm already starting to get close.
We'll see what happens.
Ciao, I'll see y'all on the moon (still).
Maxwell