Ben Tossell's Non-Technical AI Builder Playbook

Table of content

You know what’s funny about the term “vibe coder”? It completely misses the skill involved. Ben Tossell—founder of Ben’s Bites newsletter, former head of Makerpad (acquired by Zapier), and now AI investor—has burned through 3 billion tokens in four months. Every single one through a terminal. And he doesn’t write a line of code himself.

The Non-Technical Technical Class

Ben’s background is no-code tools. Webflow. Zapier. Airtable. He built 50+ products without writing code, made zero dollars from them, then turned around and built Makerpad—a tutorial site that went from zero to $30K/month profit in two months. Zapier bought it in 2021.

When AI coding agents showed up, Ben didn’t suddenly become a developer. He became something different: someone who reads agent output religiously while the agent writes code he couldn’t write himself.

“I don’t read the code. But I read the agent output religiously. And in doing so, I’m picking up a ton of knowledge around how code works, how projects work, where things fail, where they succeed.”

That’s his version of learning to program.

What He’s Actually Built

Here’s the thing—this isn’t hypothetical. In four months:

Personal site redesigned as a terminal CLI tool
Social tracker for Twitter mentions, Reddit posts, and GitHub issues (open-sourced, 100+ stars)
Factory Wrapped—built the first version, team loved it, now it’s in the actual product
Custom CLIs for Pylon, Linear, and Gmail
Crypto tracker that opens and closes positions based on AI predictions
Droidmas—twelve days of experiments touching memory, context management, vibe coding
AI-directed video demo system where the agent directs, produces, and edits its own videos
Telegram bot synced to local repos via VPS so he can code from his phone

Plus about 50 other projects left to die.

Terminal Over Everything

Ben’s workflow is CLI-exclusive. Terminal over web interfaces, always. Here’s how it actually works:

Have an idea, pain point, or problem that could be solved with code
Spin up a new project in Droid (Factory’s CLI)
Talk to the model a few times to feed context
Switch into spec mode to plan the build
Question everything: “Why this over that? Can’t we do it this way?”
Link docs and GitHub repos for the agent to explore
Let Opus 4.5 with high autonomy rip
Watch the stream, jump in when there are errors
Start the server, test it, give feedback, iterate

The gaps and issues become learning opportunities. Is this something he’s seen across other repos? Should it go into his agents.md that follows him around?

The agents.md Setup

Ben keeps a repos folder locally. In that folder is an agents.md file that instructs:

How to set up each new repo
What to do and not do
How to handle GitHub commits
Whether to use work or personal GitHub account
End-to-end test requirements (something he never paid attention to before)

“I often look at others’ agents.md files to see what I can borrow for my own. I’m constantly trying to improve my doc to make each and every new working session smoother.”

CLIs Over MCPs

Here’s a counterintuitive move: Ben stopped using MCPs. He uses CLI versions instead.

Why? Yes, MCPs eat context. But mostly it’s simpler—he usually only needs a few tools that an MCP would include. So for Supabase, Vercel, and GitHub, it’s always the CLIs.

He builds his own CLIs too. His Linear CLI lets him query issues and run everything from the terminal instead of bouncing to desktop apps.

Coding From Anywhere

The setup that lets Ben code on the go:

Droid GitHub app on every repo
Submit pull requests so Droid can review
Tag Droid to make fixes with custom prompts
Trigger from issues or PRs
VPS running 24/7 for always-on projects (like the crypto tracker)
SyncThing to sync local repos to VPS
Telegram bot connected to Droid for on-the-go access
Slack channels per repo for firing off quick tasks

Skills as Portable Tools

Ben’s moved toward Skills—not just as knowledge, but combined with bash commands and CLIs. His Gmail CLI lives at his root directory. Anytime he needs Gmail in a system, it’s there. Portable. Ready.

Learning From Real Engineers

Ben follows actual programmers like Peter Steinberger who ship constantly with almost comically simple systems—just talking to the model, letting it do its thing, no extra slash commands or subagents.

“This just gives me permission and confidence that I don’t need some ultra complex system.”

He clones open-source projects, uses them, improves them, takes parts for his own. Peter’s YouTube summarizer became Ben’s CLI version. Mario’s MCP post gave him the nudge to dive deeper into bash.

The Andrej Karpathy Point

There’s a new programmable layer of abstraction to master. In the no-code days, that abstraction was drag-and-drop tools stitched together. Now it’s learning how to work with an AI agent:

How to prompt it well
How to give it the right context
How it can help you understand what you’re doing
How the pieces work together
How to improve your system over time

Agents, subagents, prompts, context, memory, skills, hooks—this is the new stack for non-technical builders who want to ship real software.

The Takeaway

Ben’s not pretending he’s a developer. He’s something else—a translator between intent and implementation, with an AI agent doing the translation. Three billion tokens in. Fifty-plus projects shipped. Terminal-first. Learning in public.

The gaps in knowledge aren’t bugs. They’re the curriculum.

Resources: