Ben Tossell Spent 3 Billion Tokens in 4 Months — What He Learned About Building With AI Agents

Ben Tossell can't code. Never has. The guy who built Makerpad, the biggest no-code education platform on the internet, spent his career arguing you don't need to learn to code to build a company. He proved it, too. Sold Makerpad to Zapier in 2021 for life-changing money. Settled into the comfortable life of an exited founder turned investor.

Then AI happened, and Ben did something that would have been unthinkable during his Makerpad days. He opened a terminal.

In a blog post and tweet thread that's been bouncing around the no-code world, Ben revealed he'd spent 3 billion tokens in four months through the terminal. "Every single one watching an agent write code I couldn't write myself." He's shipped over 50 products. He's learned what a dependency is, what linters do, how GitHub works. Not by taking a course. By prompting agents and learning backwards from the output.

This isn't just a fun personal story. It's a glimpse at something bigger: a new archetype of builder who started in no-code and is now building with AI agents in a terminal, without ever becoming a traditional developer.

The reverse education

What makes Ben's story interesting is the learning direction. Most developers learn fundamentals first, then adopt AI tools to go faster. Ben did it the other way. He started prompting, got results, and then worked backwards: "What's a dependency? WTF are linters? How do I use GitHub?"

The AI became the teacher. The agent wrote the code, and Ben learned to read it, interpret it, and direct it. He still says he can't code in the traditional sense. But he now "understands a lot of the stack," and that understanding came from watching agents work, not from a bootcamp.

This is actually new. The no-code movement always had a ceiling. There were things you simply couldn't build without code. AI agents are dissolving that ceiling, and the people breaking through it aren't necessarily learning to code first. They're learning through the agent.

The Simon Willison parallel

Around the same time Ben was burning through tokens, Simon Willison, the creator of Django and one of the most respected developers in open source, shipped a major release of sqlite-utils that was mostly written by Claude Fable. 37 prompts, 34 commits, 30 files changed. The model found five release-blocking bugs Simon hadn't spotted himself, including a properly nasty one where `delete_where()` was silently poisoning database connections.

The cost if he'd been paying API rates directly: $149.25.

Simon and Ben are at opposite ends of the technical spectrum, but they converged on the same behaviour. Both are directing AI agents to write production code. Simon understands every line. Ben is learning as he goes. Both are shipping.

What's interesting is that Simon's use case validates the approach from the expert side. If someone with Simon's skill level trusts AI agents enough to ship a production library with them, the tooling isn't a toy. It's real infrastructure.

What transfers from no-code

Ben's no-code background gave him something most developers don't have: a product-first mindset. He spent years at Makerpad teaching people to think about what to build, not how to build it. When he started using AI agents, he already knew how to define a problem, scope a feature, and think about user experience.

Those are the skills that matter when you're prompting an agent. The agent handles the syntax. You handle the product thinking. Ben didn't need to learn to code to direct an agent. He needed to learn enough of the stack to know what to ask for and how to evaluate the output.

This is the part of the AI-accelerated founder story that gets undersold. Prompting an AI agent effectively is closer to product management than programming. You're describing desired behaviour, reviewing output, and iterating. Those are skills no-code builders have been practising for years.

What breaks

But there are rough edges. Ben's 3 billion tokens aren't free. That's real compute cost, even if Factory's eating some of it as a team member. The economics work differently for everyone.

There's also the question of what you don't know you don't know. Ben talks about learning backwards. Discovering what a linter is after shipping code that needed linting. That works for side projects and experiments. It gets more complicated when you're building something that other people depend on, or something that handles sensitive data.

Simon's sqlite-utils story is instructive here. The AI wrote great code. But Simon still did final review, still spotted documentation issues, still had a mental model of the entire codebase. When the agent missed something subtle about Python 3.12's `autocommit` behaviour, Simon caught it. Ben, or someone at Ben's experience level, probably wouldn't.

This isn't a reason not to build. It's a reason to build thoughtfully. The AI-accelerated founder path works best when you're honest about what you don't know, and when you've got guardrails. Either technical ones like tests and code review, or human ones like a more experienced developer checking your work.

What this means for no-code platforms

This is the uncomfortable question the no-code industry needs to sit with. Ben Tossell was literally the face of no-code education. He taught thousands of people to build without code. And now he's spending his days in a terminal, using AI agents to write actual code.

Does that mean no-code lost?

I don't think so. I think it means the category is blurring. Ben's still not a traditional developer. He's a product-minded builder using AI agents as his interface to code. That's not a developer. It's not a no-coder either. It's something new.

No-code platforms that insist on visual interfaces as the only valid approach are going to struggle with this shift. The builders Ben represents, the technically curious and product-first AI-literate ones, don't care whether they're building with drag-and-drop or a terminal. They care about what gets them to a working product fastest.

Some platforms are already adapting. But the ones that treat AI as a feature bolted onto a visual builder are missing the point. The interface isn't the moat anymore. The moat is how well the platform handles the messy reality of building and maintaining real software: permissions, security, data, deployment, and all the boring stuff that makes the difference between a prototype and a product.

The takeaway

Ben Tossell's 3 billion tokens aren't just an impressive stat. They're a signal. The most interesting builders in 2026 aren't the ones who learned to code in university. They're not the ones who learned no-code in 2020. They're the ones who've figured out how to think like a product person and direct AI agents like a technical lead, all without being either in the traditional sense.

If you started in no-code and you're wondering whether you should learn to code properly, the answer might be that you don't need to. You need to learn enough to be dangerous. Enough to understand what the agent is doing. Enough to catch the big mistakes before they ship.

Ben's path suggests that's not only possible. It's faster than any bootcamp.