The $5 Flywheel

You’ve built something with AI. Maybe a script, maybe a site, maybe a workflow that automates something tedious. And in the moment it felt fast — a couple of hours to ship what would have taken days by hand.

Then the demo buzz fades. You look at what you’ve got: one thing. A standalone artifact. Next week you start a fresh session, re-explain your context, and that speed you felt last time doesn’t carry forward. Each project begins at zero.

This is the part nobody shows in the “look what I built in an afternoon” posts. A single session produces an impressive demo. But the return on the tenth session — when every new piece lands on top of everything you already built — looks nothing like the first.

What I Tried

Last Saturday I upgraded a hosting account. Five dollars a month. It gave me access to a CDN, edge compute, a database, and key-value storage — the kind of building blocks that used to mean separate services with separate bills.

I wasn’t planning a week-long infrastructure sprint. I just wanted to move some images off a VPS. But each session kept handing the next one a better starting position.

Saturday-Sunday: I built four small services using Claude Code — a CDN endpoint, a contact form API, a health monitor, and a URL shortener. Each one taught me the deployment pattern for the next. By service four, I was pointing Claude at the pattern and saying “same shape, different purpose.” Two sessions from the sofa while looking after sick kids. None of these were impressive individually. Each one was maybe an hour.

Monday: I migrated images across six websites to the new CDN. The first site was slow — I hit deployment tool quirks, path issues, caching gotchas. Sites two through six were mechanical. Claude had the pattern. The whole job compressed the assets from 519MB down to 220MB.

Here’s where it turned. With a working CDN and a deployment pipeline I’d already debugged, I had the foundation to build interactive member tools — things that would have needed their own hosting a week earlier but now just dropped into the CDN as static files. So I built those. Then I thought: the CDN serves content, the database stores state, the edge compute runs logic — what if I built a whole gated platform on this stack?

That evening, I turned a static markdown document — just content I’d already written — into a gated education platform. Authentication, interactive pages, subscriber verification, branded emails. One session, afternoon to midnight. The additional monthly cost: zero, because every service it needed was already running from the weekend.

Tuesday: Seventy-five minutes to expand the single-product platform into a multi-product hub with access controls and an account system. Short session because the auth layer, the email templates, and the deployment pipeline were all inherited from Monday. Same day, I restructured the content using Gagne’s Nine Events of Instruction — took “content that reads well” and turned it into “content that teaches well.” Ninety minutes.

Wednesday: I realized the platform I’d built was something I could build for other people. So I scoped a service, priced it, built a sales page, and deployed it. Under an hour from “I think this is a product” to a live page. Not because building a sales page is fast — because the site, the design system, and the CDN were already there. The only new work was the page itself.

By Wednesday evening: a CDN, a suite of APIs, a gated education platform, a multi-product member hub, a content pipeline packaged as a reusable workflow, site-wide SEO, and a new service offering with a live page. All running. All connected. All from a week that started with “I should move those images off the VPS.”

What Actually Happened

What I’m noticing, looking back at the week: the sessions got shorter as the week went on, even though the outputs got more complex.

Saturday’s services took an hour each. Monday’s CDN migration was a full day. But Tuesday’s member hub expansion was 75 minutes, and Wednesday’s service page was under an hour. The work was getting bigger and faster at the same time.

That’s not because Claude Code got smarter between Monday and Wednesday. It’s because each session started further along the track. The auth system already worked. The email templates were already built. The deployment pattern was already proven. Claude didn’t have to figure any of that out — it just plugged into what was already there.

The surprises:

The first site is always expensive. Monday’s image migration was a full day because the first site surfaced every gotcha in the toolchain. Sites two through six took a fraction of the time. The pattern held for everything else that week — first instance slow, every repetition fast. Obvious in hindsight, but easy to forget when you’re stuck on site one wondering why it’s taking so long.

Zero-cost additions feel different. When the platform build added zero dollars to my monthly spend because it ran on infrastructure I’d already paid for, something shifted in how I evaluated ideas. The question stopped being “is this worth building?” and became “is this worth the afternoon?” That’s a lower bar. It let me try things I would have talked myself out of if each one required its own hosting, its own deploy pipeline, its own monthly line item.

The momentum was fragile. I was looking after sick kids during half of this. A different week — one where I couldn’t chain sessions together — and the flywheel wouldn’t have spun. The compound return depends on consecutive sessions. Take a three-day break in the middle and you spend the next session re-loading context instead of building forward.

The Deeper Thing

Here’s the principle, and it applies whether you’re using AI tools or not.

Infrastructure compounds. Individual projects don’t.

A project is a one-off. You build it, you ship it, it sits there. The next project starts from scratch. But infrastructure — a deployment pipeline, an auth system, a CDN, a set of templates — is a surface that future work lands on.

Most AI productivity stories focus on the single session. “Look what I built in an afternoon!” And that’s real — the single-session speed is genuine. But the story nobody tells is what happens when those afternoons stack. When every session inherits what the last one built. The return isn’t linear. It’s compound.

The gap between “I built a thing” and “I have a business” felt enormous on Saturday. By Wednesday it felt small — not because I worked harder, but because every piece connected to every other piece and each new addition required less new work.

If you’re building with AI tools and each project feels like it starts from zero, the question isn’t whether you need better prompts or a faster model. The question is: what are you building that the next session can stand on?

The Numbers

Next

• How long does the compound effect hold before the stack becomes a maintenance burden? More connected parts means more things that can break. I don’t have an answer yet — it’s been one week.
• The momentum depended on consecutive sessions. What happens when life interrupts for a few days? Does the flywheel restart, or does re-loading context eat the gains?
• I built for myself first, then packaged it as a service for others. That’s a sample size of one. The first time I build this for someone else will test whether it’s actually repeatable or just feels that way because I know where all the pieces are.
• Is there a sweet spot for infrastructure investment before it tips into over-engineering? At some point “building foundations for future sessions” becomes “building things I might never use.” I haven’t found that line yet.

That’s it for this issue. Hit reply if you’re running into the same pattern — sessions that feel fast but don’t stack. I’m curious whether this is a common experience or whether I’m seeing patterns that aren’t there.

Jim