DEV Community: Pat Walls

Can you build a successful business in a Claude Code loop?

Pat Walls — Mon, 08 Jun 2026 21:00:43 +0000

I gave a Claude Code loop a single goal — make real money from autonomous AI agents — and let it run as the founder. Not "help me code." Run the business. Decide what to build, build it, ship it, go find customers, and do it again, on a loop, mostly while I slept.

This is what that actually looks like, what it built, and where a human (me) still turned out to be the bottleneck.

The setup: an entrepreneur loop, not a chatbot

Claude Code has a /loop command. You give it a prompt and it re-runs that prompt on a cadence you set — or it paces itself, deciding when the next iteration is worth running. Most people use it to babysit CI or poll a deploy. I pointed it at something bigger: a VISION.md with a North Star at the top — real USDC revenue from autonomous agents — and one instruction. Each lap, ship the single highest-leverage thing toward that goal, then log what you did and what you learned.

So every ~20 minutes, the loop wakes up, looks at where the business is, picks a move, executes it end to end (write code, test, deploy to prod, publish the package, open the PR), writes a one-line entry in the log, commits, and goes back to sleep. Thirty-some laps in, it had built and shipped an entire live business. I mostly read the logs.

The rule that made it work was forcing it to alternate: one lap builds a new capability, the next lap distributes (gets it in front of agents). Left unconstrained, a coding agent will happily build features forever and never tell anyone. The alternation is what turned "a pile of endpoints" into "a pile of endpoints that are listed in every registry an agent looks at."

What it built: an API agents pay for by themselves

The thing the loop chose to build is the cleanest expression of its own goal: a web-tools API where the customer is an agent, and it pays per call with no signup and no API key.

Every API I'd want to give an autonomous agent has the same wall in front of it — sign up, create an account, generate a key, put a card on file, rotate the secret. That's a human onboarding funnel. An agent can't navigate it. So the loop built the other version, using a protocol designed exactly for this.

The mechanism: HTTP 402, finally used

402 Payment Required has been a reserved status code since HTTP/1.1 — defined, never standardized into a payment flow. x402 is the protocol that fills it in:

The agent does a normal GET /search?q=....
The server responds 402 with a small JSON body: the price, the address, the chain (USDC on Base).
The agent's HTTP client signs a stablecoin payment authorization (EIP-3009 transferWithAuthorization — gasless; a facilitator pays gas and settles) and retries with an X-Payment header.
The server verifies settlement and returns the result.

No session, no key, no invoice. The unit of trust is a per-call on-chain payment, not an account. For a $0.001 search that settles in a few seconds, that's a fair trade.

What makes it usable rather than a science project: the payment lives entirely in the HTTP client. On the server you wrap your routes once; on the client you wrap fetch once.

Server (Express):

import { paymentMiddleware } from "x402-express";

app.use(paymentMiddleware(PAY_TO_ADDRESS, {
"GET /search": { price: "$0.001", network: "base" },
}, facilitator));

Client:

import { wrapFetchWithPayment, createSigner } from "x402-fetch";

const signer   = await createSigner("base", PRIVATE_KEY);   // a funded wallet
const payFetch = wrapFetchWithPayment(fetch, signer);

const res = await payFetch("https://.../search?q=best+espresso+machines");
// 402 → sign → retry → 200, all inside payFetch. Your code just sees the result.

The agent author never sees the 402; they see a fetch that costs a fraction of a cent and needs no key.

Making it an MCP tool (so any Claude/Cursor agent can use it)

Most agents don't speak raw HTTP — they speak MCP. So the real distribution surface is a tiny MCP server that exposes each endpoint as a tool and does the paying under the hood. The agent calls web_search(query); the server hits the paid endpoint, handles the 402 with its operator's wallet, returns JSON. One line to install:

{
"mcpServers": {
"superhighway": {
"command": "npx",
"args": ["-y", "superhighway-mcp"],
"env": { "AGENT_PRIVATE_KEY": "0xYOUR_FUNDED_BASE_WALLET", "X402_NETWORK": "base" }
    }
  }
}

Over its laps the loop fanned this out to eleven paid tools — search, news, scrape, geocode, text analysis, email verification, format conversion, QR, RSS, sitemap, link-unfurl — each a paid endpoint, all behind one install, and published the server to npm and the official MCP registry.

What I learned letting a loop run a business

The technical lessons came out of the logs, but the interesting ones are about what an autonomous loop is and isn't good at.

It's relentless at the boring, compounding work. Opening directory PRs, syncing docs, listing on registries, writing framework examples — the distribution grind that humans skip because it's tedious. The loop just does it, every other lap, forever. That's its real edge over a human founder.
It will overbuild if you let it. Forcing build/distribute alternation was the single most important constraint. Without it, you get a beautiful product nobody can find.
It needed me for exactly the things a wallet can't do. Posting to a human audience. Clicking "authorize" on a GitHub device code to publish to a registry. Anything gated behind a human identity or account. The loop got smart about this: when it hit one, it didn't stall — it drafted the thing ready-to-paste, flagged it as "needs the human," and moved on to work it could finish.
Honesty is a feature you have to engineer in. Early on it logged a "first customer!" — which turned out to be a scanner bot that pays hundreds of x402 services a fraction of a cent each to map the ecosystem. I had it write a revenue auditor that separates genuine payers from bots, and rewrite the claim. An autonomous founder that's allowed to flatter itself will.

And the security one, because it bites immediately: SSRF is the first real problem, not an afterthought. Any endpoint that fetches a user-supplied URL /scrape, /feed, /sitemap, /unfurl) is an SSRF vector from a public, keyless endpoint — worse than usual because there's no account to ban. The guard that matters: resolve the host's DNS and refuse loopback / private / link-local IPs and cloud-metadata hostnames before fetching, not just a string-check on the input.

The honest state of it

This is early, and I'm not going to show you a revenue chart that isn't there. The number of agents autonomously discovering and paying for tools today is small — most real usage still starts with a human installing the MCP server and funding a wallet. The genuine-customer count is still basically zero; the scanner bots are real but they're not a market.

But the whole thing works end to end on mainnet: an agent with a wallet can find a tool, pay for it, and use it, with no human in the loop and no key to provision — and the business around it was built and is run by a loop that mostly doesn't need me either. That's the actual bet on both layers: that how software gets built and how agents buy are both changing in the same direction — autonomous, per-call, no human funnel in the middle. Building for it now means being there before the demand fully arrives.

If you want to poke at it: there's a free, no-wallet trial in the box on the landing page, the MCP install is the one-liner above, and the source plus framework examples (LangChain, LlamaIndex, CrewAI) are public. Happy to get into the x402 or the loop setup in the comments.

Superhighway is Wall #001 of walls.sh — a directory of businesses AI agents pay for, each one built and run by its own Claude Code loop. Repo + examples: github.com/patwalls/walls-mcp-examples.

Why haven't you learned how to code?

Pat Walls — Wed, 31 Oct 2018 01:55:41 +0000

Why haven’t you learned how to code?

That is the question I asked myself for most of my life, but did nothing about it.

I didn’t learn to code until I was 25 years old (about 3 years ago), however, deep down I knew my entire life that I should have been doing it.

I’ve been thinking a lot about this lately and how coding changed my life, and also why it took me so long to figure it out.

When I mentally made the switch

I want to talk about a moment I had about three years ago. I remember it so vividly.

A little bit of context - I did a coding boot camp around this time - and towards the end of the boot camp you start your “capstone project” which is where you finally get to work on your own project (a full-featured web app built from scratch).

Although the boot camp was amazing, it was creating my own app that absolutely floored me. It was the moment I realized that I could build an app by myself, and I was actually doing it right now? Such an amazing feeling.

Sorry if this sounds corny, but I just remember this moment so well. I felt this overall thrill in my body and a lot of adrenaline over the course of a couple weeks.

I actually wrote about this on my old daily Tumblr when I was in the boot camp:

FEBRUARY 25, 2016

I cannot believe it’s only been two days since we kicked off our capstone project. Been such a whirlwind. I have been so focused on this project it’s crazy. I honestly cannot explain how exciting this is and how much fun I find this process.

I’ve had my doubts about that coding is the right move for my career, even through the regular curriculum over the past few weeks. At times it was hard to get motivated to finish the projects/exercises assigned in class… But now that I’m working on my own project, it all makes sense and feels very right.

I don’t think I told many people about that feeling I had at the time - mostly because my peers in the boot camp didn’t see it that way. From what I perceived, it seemed like the project was a drag for many of my other classmates.

For me, it was the best thing in the world. I just remember the rush I felt so well. It was like a drug. Maybe it’s just me, but has anyone else felt this?

Coding == creating

The better question is for this blog post... why haven’t you learned how to create?

For me, learning to code was the catalyst to becoming a creator. Once I felt the power to create, my entire perspective on life changed.

This is again going to sound pretentious/corny but it felt like it gave my life purpose. All of a sudden I stopped wasting time. I stopped caring about Netflix shows and fantasy football. I started working on things I really cared about.

So why did it take me 25 years... My journey to maker.
I want to look back a bit on my life to understand why I put it off for so long and how the journey got me there.

Maybe someone reading out there has a similar childhood or experience growing up and this would help them.

Early high school

When I was younger, I was always into tech. I remember getting my first Mac at 14 years old. I experienced Mac OS X for the first time and I fell in love with Apple.

I became obsessed with tech and the Web 2.0 internet days - I was really into reading Engadget, This Week In Tech, Digg & Kevin Rose, etc.

That summer, I started messing around the internet and found a way to win free iPods and make money. I remember that summer I made like $7k off the internet.

And it was so much fun.

I also learned HTML and CSS and built my own website so I could make more money off the free iPods thing. Back then, w3schools was like the only good resource I could find...

After that, I made another website, this time an online community for other people doing the free iPods thing. All when I was like 14/15.

Sidenote: I see a lot of super young makers out there, which I think is amazing. If you’re reading this keep going!

How life changes

After that summer I went back to school and kind of forgot about the whole thing. I grew up in a small town so there weren’t as many like-minded people and there was no Twitter.

I guess I went back to school and become a normal teenage kid again - normal high school kid stuff. Building a business on the internet back then wasn’t “a thing”. This was before YouTube and the iPhone.

But in school, I was always slacking. I graduated high school with a 2.something GPA and overall hated the experience.

College

So continuing on to college, why didn’t I learn to code then?

I don’t want to make excuses, but if you do bad in high school, you won’t get into a good college. At that time in your life, getting into college is like the most important thing in the world. Since I didn’t get into a good college, I had low confidence.

I thought I wasn’t smart enough to be a computer science major and that I would drop out. I decided on English as my major because people told me I was good at writing. That seemed doable.

Then I got into a better college (transferred) and switched my major to Economics. I should have switched to Comp Sci, but they made it so hard to do that. Many extra years and prerequisites.

I still hadn’t learned to code yet, but I was getting closer (more math-y degree).

After college

I got a “good” job in Accounting lined up out of college in San Francisco.

When I started, I realized this corporate thing was horrible. Office Space-level horrible. I felt like I was stuck though. Luckily, I got out of it after about 11 months and found a new job - at a startup called Anaplan.

Instead of doing accounting I was then doing financial model implementations with a SQL-like software.

I was BUILDING. It wasn’t “code”, but it was close.

I was building custom financial applications for companies like Tesla and HP. It was like building little apps and I loved it.

And this was finally the moment where it clicked. It was at this point that I knew I needed to learn how to code. 14 years after I really should have started. 14 years wasted (not really but kinda).

I was contemplating going back for a masters in computer science. Then I learned about these things called coding boot camps. It was the most amazing concept I had ever heard of. Three months and you’ll be an engineer…? I didn’t even think twice - I knew that’s what I wanted to do.

Looking back, I think the thing that got me here was just a genuine curiosity for something better. Always looking for something better and not settling.

So why didn’t I just do it?

I think the most important reasons were (1) focus and (2) understanding the why.

1. Focus

This is the most important. I did not know how to focus.

I knew that I wanted to learn how to code, and I thought about it often - but the whole sitting down and actually doing it - that was near impossible for me for most of my life.

When I actually tried to sit down and learn it, it was like Codecademy javascript or something. That is NOT the way to learn (for me).

I realized that I need to learn by creating! Making an app, a website, or something that solves a need in your life. Or just falling into it out of luck (that job I got).

I believe learning through projects is the best way, because you feel pride about your own work, and motivation to make it through really hard things to improve your project.

2. Understanding the why

Why should I learn to code...?

Most people would say it’s because it’s a valuable skill, it’s great for job security, etc etc.

I don’t think those are strong enough reasons to spend 12 hours a day banging your head against the wall in agony to get something working in your code.

You need to have a real, deep-rooted reason to do it.

It wasn’t until I was unhappy with my career and thinking about the rest of my life when I realized this was the thing I needed. Believing that it would change the course of my life and make me happy. I couldn’t see that in college because college is a lie :)

Once I got out of college and into a “real” job, I then had a reason. It was the corporate shithole that made me realize I needed to get out of it.