If your plans stay the same while AI keeps getting better, it will end up doing most of the work they need. That's the threat everyone sees. But your plans don't have to stay the same. As machines take on the execution, our work moves up the chain: deciding what's worth doing, owning the consequences, and attempting what used to be out of reach.
In short
Keep your goals fixed and AI means fewer people doing the same work. Raise them as fast as AI raises what you can execute, and it means more of what you care about gets done.
Work starts before the tasks: conviction, then intent, then the spec, then the tasks. In my software factory, the intent is the entry point: the factory helps you articulate it, writes the spec with you, and runs everything after. The conviction stays yours.
Intent belongs to whoever adopts it. AI can propose the goal and argue it better than you, but choosing it, delegating to it and answering for it stay yours.
The most dangerous thing an AI can give you is a flawless implementation of a spec you've already outgrown. Tests can prove it does what you agreed; only you can say you still want it.
Companies can turn five people serving one outcome into five people owning five, if they hand over the authority with the accountability. Regulation should leave room to try, and scale the evidence to what can't be undone.
If your plans stay the same
If my plans stay exactly the same while AI keeps getting better, eventually it will be able to do most of the work those plans require. I understand why that feels threatening. We've built careers, teams and companies around our ability to execute that work.
But my plans don't have to stay the same.
A project I could never afford might become possible. A problem that needed a whole team might become something I can own myself. A business I dismissed as impractical might deserve another look.
That's where my optimism about AI comes from. As the capacity to execute goes up, our ambition should go up with it.
As machines take on more of the execution, our work moves to deciding what's worth doing, owning the consequences, and attempting more.
Taking that opportunity is a deeper change than learning to prompt a model. It changes what we consider our work, how companies hand out responsibility, and where we spend our attention. In my post on software factories I quoted OpenAI's team, which built a product with no hand-written code: "Humans steer. Agents execute." This post is about the steering. And I think it starts with conviction.
I first made this argument on video in September. This post is the written version, rethought around the software factory I've been building since.
Watch on YouTubeWork begins with conviction
We usually describe a job by its tasks. Developers write code. Designers draw interfaces. Marketers run campaigns. Managers coordinate the people doing all that.
Look at work through that lens, and every task an AI can do removes a piece of someone's value. Keep the output fixed, and the logic leads to fewer people doing the same work.
But a task exists because somebody wants something to happen. Before anyone writes a ticket, someone has looked at the world and decided a problem deserves attention: a customer experience should be better, a service should exist, an accepted way of doing things should change.
The chain I have in mind:
| Step | What it is | Where it lives |
|---|---|---|
| Conviction | The belief that something is worth pursuing, held strongly enough to act on | With you. The factory can challenge it and help you shape it, but it's yours |
| Intent | The outcome you decide to pursue because of that belief | The factory's entry point: you bring it, the factory helps you articulate it |
| The spec | The intent made concrete: the objectives, how each one will be verified, the constraints, the authority given | Inside the factory, written with you |
| The tasks | The work that makes it happen | Inside the factory: agents build, verify, release and observe |
That last column is where my definition of a software factory matters. The factory isn't the machine you hand the spec to once the thinking is done. In my definition, it's the whole lifecycle, from the moment a request arrives until its outcome is met in production. The intent is how you enter it. From there it's one loop: the factory questions the intent, writes the spec with you, builds, verifies, releases, watches the outcome, and comes back to the intent when the outcome isn't there.
Where conviction and intent sit in my software factory: the conviction stays yours, outside the factory; it enters as an intent, and from there everything is one loop inside the factory: interrogate and refine the intent, write the spec with how each objective will be verified, build and verify, release, observe the outcome, and back to the intent when the outcome isn't met or you've outgrown it. The factory comes back to you with its questions and the decisions only you can make.
The diagram as text
- Outside the loop: Your conviction (Yours. The factory can challenge it and help you shape it) → Enters as an intent → The intent. And back from the loop: Its questions, and your decisions.
- The software factory (Everything from the intent on): The intent (The entry point: what you want to happen) → Interrogate and refine (The factory helps you articulate it) → The spec (The objectives, and how each one will be verified) → Build and verify (Within the authority you gave it) → Release (To a few, then everyone) → Observe the outcome (Is the objective met?) → back to The intent (Not met, or outgrown: back to the intent).
- Out of the loop: Met (The outcome is there, for real users); Abandoned (Your call, on the record).
The conviction is the one part that stays outside. It can be born in a conversation with the factory, or sharpened by it: an agent that digs through your customers' support tickets can make you believe something you only suspected. But the belief, and the decision to act on it, are yours.
AI's growing ability to do the tasks makes everything above them more consequential. We can spend less effort arranging every step, and more deciding whether the destination deserves the journey.
Conviction has a cost, though: you can be wrong. You can misread your customers, back the wrong product, or spend months on a problem that matters far less than you thought. When that happens, you have to answer for it: say what happened, change direction, and deal with the consequences for the people affected.
That's why, for me, conviction and responsibility go together. An opinion is easy to express. A conviction means something when you commit to it and stay accountable for the result. It also means changing your mind: enough conviction to act before you're certain, and enough openness to see the evidence that should change your view. Standing behind a decision includes taking responsibility for correcting it.
Intent belongs to whoever adopts it
The obvious objection: what happens when AI gets better at choosing the goals, too?
Say a model proposes a strategy I'd never have imagined. It understands the market better than I do, spots the opportunity, explains how to get there, and argues for it more convincingly than I could. My argument still holds, because it isn't about who's smarter. It's about whose purposes the system serves, and who chooses to commit.
Two people can understand the same situation perfectly and still want different things. One wants to build a large company. Another wants a small business that gives them independence. One wants to polish a familiar product. Another wants to chase an uncertain idea because they believe it should exist. More intelligence helps them see the consequences. It doesn't settle which future either of them should want.
An idea doesn't have to start in my head to become mine. Books, conversations, customers and colleagues already shape what I want, and AI can be part of that. What matters is whether I understand the direction well enough to choose it, and stand behind it.
An AI having an intention wouldn't make that intention mine.
Even "let the AI run my company" is a decision about delegation. I'm choosing the goals, how much authority I give away, and the conditions under which it should continue. That's the same question I ask of every AI step in how much freedom should an AI step get?, at the scale of a business.
And the model doesn't take on my obligations to the people affected. If I authorise a decision that damages a customer's business, pointing at the model doesn't fulfil my responsibility to that customer. I still have to respond, explain, and help put it right.
The spec makes the intent concrete
Conviction and intent are still too vague to build from. "Make the customer experience better" leaves almost everything open.
This is the factory's first job, and where working with AI pays off the most. In my factory, a request isn't accepted as written: the factory interrogates it, through a structured interview like Matt Pocock's grill-me skill, and it can refine it, prioritise it, or decline it (what my factory does with a request). It inspects the system, questions my assumptions, explores implementations and exposes consequences I hadn't thought of. Together, we turn an intention into something specific enough to build, and to check.
Here's a concrete case. Say I run a software business, and I hold this conviction: small customers should get useful results without first becoming experts in my product.
That gives an intent: a new customer reaches their first useful result without a support call.
An AI going through the existing onboarding might find that some steps are useless. It might also find that others set up access permissions, or collect information the product needs to work. Remove all the friction, and you may remove protections, or hide decisions the customer still needs to make.
Now we're having a useful conversation:
- What counts as a useful result?
- Which choices can the system safely make for the customer, and which need their judgment?
- What happens when one of its guesses is wrong, and can the customer recover without calling us?
The spec captures the answers: the experience we want, the constraints, the trade-offs we accept, and the authority the factory gets. It also keeps enough of the reasoning behind the intent to guide the decisions nobody anticipated. In my projects, that's a folder per objective, holding the intent, the objectives, the plan and an audit of every decision (the spec is the session's memory).
And the part of the spec I care about most: how each objective will be verified. Not "we'll test it". Where, and against what: the observable expectation, the check that proves it, where that check runs (a unit test, an end-to-end journey, a preview, an observer in production), and what evidence will count. If nobody can say how we'll know it worked, the spec isn't ready, and my factory doesn't build it. Verifiability is a condition of entry, not an afterthought.
Here's what that looks like for the onboarding intent:
| In the spec | For the onboarding intent |
|---|---|
| The objective | A new customer reaches a first useful result without a support call |
| How it's verified before release | An end-to-end test walks a brand-new account through onboarding with no human step, and checks the permissions and the data the product needs are still set |
| How it's observed after release | The share of new customers who reach that first result, and how many of them open a support ticket in their first week |
| What the factory may do alone | Remove, merge or pre-fill steps, fix what's broken, release to a few customers first |
| What comes back to me | Collecting new personal information, changing prices, removing a step the law or security needs |
That verification row is what makes the rest possible. In Verifiability is your next AI investment I argued that the limit on what agents can do for you isn't their capacity any more: it's how much of their work you can trust, and only verification raises it. Every objective the spec makes verifiable is an objective the factory can carry without me. What verifiability means has the five parts I hold every check to.
A spec without its checks is a wish.
Writing it is an act of discovery. Something the AI uncovers can change the intent I started with. Something that sounded great in the abstract can turn out to have a consequence I won't accept. That back and forth is where I want to spend a big part of my time: the machine challenging the proposal, exploring its effects, and helping me reach an agreement we can execute with confidence. It's also why I review outcomes, not code (I review outcomes, not code): the judgment I add is in the spec and in the result, not in the diff.
The factory runs the loop
Once the spec is agreed, I want the same factory that helped me write it to carry it through to the end.
That's the rest of my software factory: it turns the agreed spec into a working system in production, watches the result, and feeds what it learns back into the intent. Planning, building, testing, releasing, monitoring, investigating failures and fixing them, within the authority it's been given. A human relaying every result from one stage to the next would keep exactly the coordination work I want gone.
The system around the models matters as much as their intelligence. It has to verify its own work, limit the damage of a bad change, recover when something fails, and record what it did. I've written about each of those: verification is the engine, one-way doors for the changes you can't take back, and the rules I give my factory, starting with "bound the authority".
The agreement also has to say when the factory carries on by itself and when new evidence needs a person. In the onboarding case, the factory might find a broken form, fix it, run the checks, release the fix and watch the result. That's inside the agreed outcome: carry on. But if it finds that hitting the target means collecting more personal information, or charging customers differently, it has found a decision about what we're willing to do. That goes back to the owner.
The boundary is the authority I gave the system. Inside it, the goal is full execution with no human stepping in. A change to the agreement needs a new decision. The person doesn't have to be present, only available: decision APIs measure how sure the agent is at each decision point, and call someone when it isn't (humans: available, not present).
There's a tension here I've lived many times with agents. A spec that looked right in the morning can feel wrong before lunch. Building something shows you the problem differently: you see a consequence you missed, or you realise the outcome you agreed isn't the one you want any more.
The most dangerous thing an AI can give you is a flawless implementation of a spec you've already outgrown.
A spec you've outgrown, as an illustration: over one morning, the implementation catches up with the spec exactly and every test passes, while what you actually want moves away from both.
The diagram as text
- 9 a.m. → 10 a.m. → 11 a.m. → Lunch (An illustration of the argument, not a measurement.)
- One morning with an agent (The tests compare the implementation with the spec. Nothing compares the spec with what you want now.): The spec: written at 9 a.m., and it doesn't move; The implementation: catches up with the spec exactly, and every test passes; What you want: moves away, as building shows you the problem.
Tests can prove the implementation does what we agreed. They can't prove I still want what we agreed, or that it was a good idea in the first place. Verification raises how much work I can trust; it doesn't decide what's worth doing.
So I step away from the execution, but not from the result. Feedback from production starts another conversation about the intent, another spec, another run of the factory. When the objective has drifted too far from where it started, the old one is archived and a new one forks from it, with everything it learned (when is it done?). Ownership carries on through that loop.
Ambition has to grow with capability
Now imagine the factory keeps getting better. More work becomes reliable enough to delegate. Problems that took weeks take days. What one person can do keeps growing.
If we keep our ambitions fixed through all that, we'll need less and less human effort to reach them. That's a fair conclusion from a fixed set of goals. My answer is to question the goals too.
Two ways to spend what AI can execute, as an illustration: keep the ambition fixed, and the people needed shrink towards none; raise the ambition as fast as the capacity, and the same people own more and more.
The diagram as text
- Today → The next model → The one after → Later (An illustration of the argument, not a measurement.)
- Same ambition (The goals stay where they are.): What AI can execute: grows with every model; What we set out to do: stays the same; The people it needs: fewer and fewer.
- More ambition (The goals grow with what can be executed.): What AI can execute: grows with every model; What we set out to do: grows with it; The people it needs: the same people, each owning more.
For every increase in what AI can execute, raise what you're prepared to own.
I mean it as a practical discipline. When a project gets dramatically easier, reconsider the scale or the quality of the outcome you're aiming for. When something that needed a team becomes manageable by one person, ask which impossible problem that person could take on now.
Ambition and intelligence won't come in matching units on a dashboard. What I care about is the relationship between our usable capacity to act and the outcomes we choose to pursue. And "usable" matters: in the verification post I argued that the ceiling isn't what the agents can produce any more, it's how much of it you can trust. Raise that ceiling, and your ambition has room to grow into it.
If our ambitions grow as that capacity grows, the gains turn into progress on things we care about. And if we start imagining faster than the systems can deliver, execution becomes the bottleneck again, and we want better AI because there's more we want to do. I'd much rather have that problem.
Back to the onboarding case. Once serving a small customer no longer needs hours of manual support, maybe the business can serve customers it could never afford to help before. The ambition grows from fixing one workflow to opening the whole product to more people.
That's why the picture of a fixed pie doesn't convince me. Today's backlog reflects what we can currently imagine, afford and organise. It's a poor measure of everything worth doing. I don't see an endpoint where every experience is good enough, every useful idea has been explored, and nobody wants to make anything different.
Every project still has limits: money, attention, energy, demand, and how much responsibility you can carry. Growing your ambition means choosing problems worth solving within those limits, and looking again as the limits move. It can mean better quality, more people served, or a business that gives its owner more freedom. It can mean solving a whole problem instead of managing its symptoms forever. And an ambitious outcome can be the system doing enough of the work that you get part of your life back.
It still has to be judged by the people it's for. As I wrote at the end of the factory post, the winners are the companies whose customers judge their product the best. More ambition doesn't change that test. It just lets you aim higher on it.
Learning expands what you can imagine
There's a practical obstacle to being more ambitious: you tend to want the things you already understand well enough to imagine.
That's why learning stays at the centre of all this. Every new idea or perspective can show you possibilities you couldn't see. As an engineer, I come at a problem through architecture and implementation. Learning more about design might show me the real problem is that people don't understand the product. Learning about distribution might show me the product is useful but never reaches the people who need it. A different business model might make an impossible service viable.
AI helps me explore all of those. I still have to engage enough to see what they change about the problem and what I want to do next. It's the first rung of the trust ladder applied to everything else: get familiar, early and often, or you won't notice what's become possible.
My expertise stays useful. It helps me ask better questions, spot answers that don't add up, and judge the consequences of a proposal. But it becomes a foundation to build on, with easy access to perspectives that used to cost a degree or a career change.
Learning expands what I can meaningfully want. That makes it part of ambition itself.
Companies need to hand out ownership
All this matters much more inside an organisation.
Picture five people contributing to one outcome. One writes the requirements, one designs the experience, one builds it, one tests it, one coordinates. If AI does a growing share of that execution, the company has two options:
| Same ambition | More ambition | |
|---|---|---|
| What changes | Fewer people deliver the same outcome | The same five people own five outcomes |
| What each person needs | Nothing new | Authority to decide, access to customers and evidence, resources to act, and a clear view of the consequences they own |
| What the company gets | The same product, cheaper | More of the product, and more of the market, served |
The second option means changing the organisation. Calling someone an owner while they need approval for every decision leaves the old system intact: they've gained the accountability without the means to exercise it.
I want companies to try handing out more of both. Give people problems worth solving, and room to carry them across the borders of their old specialty. Their engineering, design or commercial skills serve the outcome, and their colleagues cover what they can't responsibly cover themselves. In the first post I wrote about the old friction between developers and the business, and the layer of management companies keep between them. An engineer who owns an outcome doesn't need that layer. And the culture that results ends up in the product: your factory is your culture.
I'm a solopreneur. Cloudless Labs is an umbrella over two businesses: Lin Wong runs the e-learning practice, and the IT consulting, HappySkills and my other projects are mine. So this way of working comes naturally to me. I wake up with problems that belong to me. Whether the answer involves code, marketing, customer support or changing the product is mine to figure out, and more execution capacity widens what I can consider. HappySkills is the kind of product I wouldn't have attempted alone a few years ago.
But I know it's a temperament I happen to enjoy. Some people prefer clear boundaries, or deep focus on a craft. Giving them more autonomy takes support, learning, and an honest conversation about what they want. Handing someone a bigger problem and calling it empowerment is just poor management.
Nor does more ambition guarantee that every job automation removes gets replaced. Real opportunities, demand, investment and access to the tools still matter, and companies and societies have to make the transition possible. My argument is narrower: we have more choices than the fixed-output view of automation lets us see.
Regulation should leave room to act
Here's my reading of where we are: we've stopped expecting extraordinary progress, and started organising our institutions around controlling uncertainty.
Peter Thiel makes a related argument about science. In a March 2026 interview with The Harvard Salient, he blamed part of decades of slower progress on bureaucracy: "My libertarian intuition is that the bureaucratization and formalization of science came at a long-term, multi-decade cost." And on how new technology is received: "If we have more technologies, it's just seen as scary." He puts more of the weight on culture than on institutions, but the direction is the same.
That's why I worry about regulation driven by the fear of change. When institutions spend more effort preventing uncertainty than enabling progress, caution becomes our highest ambition. If the answer to more capability is to make experimenting slower, more expensive and more dependent on permission, we stop people turning new ambition into action, and we organise the future around the limits of the present.
That matters most for individuals and small teams. What excites me is that far more people could gain the capacity to build and own something meaningful. Rules that make trying prohibitively hard would kill exactly that.
The principle I want is ambitious experimentation with clear responsibility for the consequences. A good rule sets obligations, protects the people a decision affects, and makes it clear when you're allowed to act. My concern is regulation that treats uncertainty itself as a reason to stop.
What I'd want instead follows the same logic as the software factory: make actions visible, limit the damage a failure can cause, build ways to recover, and learn from what happens. Where an action can do serious harm that can't be repaired, the evidence needed before acting should rise to match, the same way a one-way door in my factory gets a different plan from a display bug. Safeguards like that make room to build. When protection becomes a permanent requirement to keep things as they are, we've let fear set the limit of our ambition.
What would prove me wrong
- Demand doesn't grow. If cheaper execution only makes the same products cheaper, and customers don't want more, better or new things, the fixed pie was right and fewer people do the same work.
- People don't want to own outcomes. If most people, offered the authority, would rather keep a bounded role, companies take the cheaper option, and they'd be right to.
- Companies keep the accountability and withhold the authority. "Owner" becomes a title with an approval chain behind it, and the ambition never reaches the people who'd act on it.
- The trust ceiling stays low. If most work can't be verified well enough to delegate, the capacity to execute doesn't really grow, and there's nothing for ambition to grow into.
- Regulation was protecting something real. If the harms of fast, cheap experimentation turn out to be mostly the kind that can't be undone, caution earns its place.
My bet
I want AI to take as much of the execution off my hands as it reliably can. I'll use that freedom to go after problems I couldn't attempt before. As the machines get more capable, I intend to get more ambitious, and to stay responsible for what that ambition produces.
The future I want is one where many more people can take a conviction, turn it into a clear intent, work with machines to make it concrete, and see it through to an outcome. That asks more of us: deciding what matters, choosing under uncertainty, answering for it when we're wrong, and learning enough to imagine past the work we already know. In exchange, we get to attempt things that used to need resources, expertise or organisations far beyond our reach.
So here's my question for you: if AI took care of the execution, what would you finally take responsibility for making happen?
On this site
Sources
Written by Nicolas Dao.
