The first time, it was a chatbot in the corner of the website. It answered questions, deflected some tickets, and never actually did any of the work. A better FAQ, not a workforce.

The second time, it was a copilot. It made one person faster at one task, as long as that person sat there and drove every step. Real progress, but bounded by a hard ceiling: your attention. You can supervise one copilot at a time, and it stops the moment you stand up.

Neither of those runs anything. The next step does.

The definition

An autonomous company is a team of AI agents that work together to run real business operations.

Four properties separate it from everything that came before:

1. Each agent has a job, not a chat window. One answers the phone. One handles bookings on WhatsApp. One does research and drafts the outreach. You staff it the way you staff a team: by role.
2. They share knowledge. Your pricing, policies, and documents live in one place, and every agent works from the same source of truth. When a document changes, every agent knows, on every channel.
3. They hand work to each other. The front-line agent pulls in the specialist when a conversation goes deep. Work flows between agents the way it flows between coworkers, without a human routing every step.
4. They act without being asked. Real employees do not sit silently until spoken to. Agents in an autonomous company follow up with customers, send the weekly digest, and flag what needs attention, on a schedule, proactively.

What it looks like in practice

Take a clinic. A voice agent answers the phone around the clock, checks availability, and books the appointment. A WhatsApp agent handles the "can I move my Thursday slot" messages. A knowledge agent stays current because it learns straight from the folders where the practice already saves its documents. An outreach agent sends recall reminders on schedule. And when a conversation needs a human, a human takes over mid-thread, with full context.

No single chatbot does that. A team does. That is the difference in one sentence: a chatbot talks about the work, an autonomous company does the work.

Autonomy is not the absence of control

"Autonomous" does not mean unsupervised. It means the supervision moves up a level: from driving every step to setting direction and boundaries.

You decide what the agents know, which channels they live on, what they are allowed to spend, and when a person steps in. Budgets are capped. Sensitive actions wait for approval. Every conversation is visible, and takeover is one click. An autonomous company is accountable by construction, because accountability is what makes the autonomy safe to grant.

We run part of ours this way already

This is not a thought experiment for us. Chipp's own engineering runs on autonomous agents that field tickets, fix bugs, and ship code while the team sleeps. We have written extensively about that system here on this blog, starting with the Autonomous Development Manifesto.

Engineering was simply the first function to cross the line, because software is where the tooling matured first. Support, operations, outreach, and scheduling are crossing it now. The curve is the same every time: first a tool that talks, then a tool that assists, then a team that runs.

How to start

Not with a platoon. Autonomous companies are grown, not launched.

Start with one agent doing one job well: the phone line, the booking flow, the support inbox. Give it your knowledge, put it on the channel where the work actually happens, and watch it. When you trust it, add the second agent, connect them, and let them hand work to each other. Autonomy is earned one role at a time.

That is exactly what Chipp is built for. More than 125,000 agents already run on the platform, and they have carried over 14 million conversations for real businesses. The infrastructure for building an autonomous company, without an engineering team, is no longer the hard part.

The era of autonomous companies is here. You're early.

Start building

This week in AI:

• A Brown professor's chart caught (almost) his entire class cheating with AI — and 16 million people watched
• New data reveals what workers *actually* fear about AI, and it isn't losing their jobs
• The AI money is quietly shifting from the cloud giants to the chipmakers
• ESPN rolled out an AI that reads poker players' faces live on air
• And the case for going independent has never looked stronger

There's a clear through-line this week: AI isn't erasing work — it's redistributing leverage, toward the small, the independent, and the people willing to rebuild how they work.

On the Chipp side:

• 🎙️ Chipp Chatter is now a live show. Catch it and never walk into a meeting (or a dinner party) unprepared: Get notified on YouTube →
• 🎪 Chipp Con: Fargo — July 30. Afternoon workshop + evening Night Bazaar. Details →

AI Highlights from Around the Web

All But 3 Cheated: A Brown Professor's Chart Went Nuclear

Paul Graham surfaced the AI story of the week and 16.3M people watched it. A Brown professor (Serrano, ECON 1170) gave a take-home midterm, suspected widespread AI cheating, and made the final in-person. Then he plotted both. The orange dots (take-home midterm) cluster in the 90s and 100s. The gray dots (in-person final) collapse into the 30s, 40s, and 50s. His verdict: *"Looks like all but 3 cheated on the midterm."* Oh, and once the final went in-person, 18 students dropped the class and 9 didn't show.

Explore this tweet →

🌶️ The take-home exam didn't get cheated — it got exposed. It was never measuring what everyone pretended it measured. Businesses are having this exact reckoning right now: if the work can be done with AI at home, then "can you do it *without* AI" is the wrong test. The move isn't to ban the tool and drag everyone back into the room — it's to assume AI and raise the bar for what "good" even means. The professor found his cheaters. The harder question is what a take-home should ask at all in 2026.

What Workers Are Actually Afraid Of (It's Not Layoffs)

Lenny Rachitsky dropped a large-scale survey on AI and work, and the headline finding flips the usual narrative. "Losing my job to AI" came in *near the bottom* of workers' fears, at just 22%. What actually keeps people up: being asked to do more for the same pay (51%), an unsustainable pace (46%), and watching the quality of their work slip (41%). In his words: *"Every gain becomes the new baseline, and the people expected to hit it are running out of room to breathe."*

Explore this tweet →

🌶️ This is the most honest chart about AI and work we've seen all year. Nobody's lying awake over "the robots are coming" — they're exhausted because every productivity gain instantly became the new floor. Here's the Chipp read: the squeeze is real, but it only crushes you when AI stays a personal side-hustle instead of a system. When agents own the coordination layer — the scheduling, the follow-ups, the tier-1 support — the extra output doesn't come out of your evenings. Build the system, or become the system.

Meanwhile: Founders Are the Happiest People in Tech

From the same report, a finding Claire Vo flagged as *"spitting true facts"*: through the most turbulent year tech has ever had, the biggest results came back almost unchanged. Founders are still the happiest people in tech, and smaller companies are still better places to work than big ones. The honest caveat — the whole industry runs on a high baseline of burnout, so the "winners" are the people who feel a little less of it. But founders don't just win on comparison; on most measures, they're genuinely happy.

Explore this tweet →

There's Never Been a Better Time to Get Rich Working Alone

Derek Thompson tied the whole theme together in a new newsletter. He calls out the two lazy camps in the AI-and-jobs debate: the Doomers (AI takes every job — except unemployment is low and prime-age employment is high) and the Deniers (AI is a worthless scam — which blinds them to how it's already reshaping the economy). His evidence-based take instead: *"There's never been a better time for workers to get rich by going independent. This is a golden age for tiny startups with big revenue."*

Explore this tweet →

🌶️ Thompson nails the exit from the tired doomer-vs-denier shouting match: the real story is that one person with AI can now run what used to take a team. "A golden age for tiny startups with big revenue" isn't a prediction for us — it's our org chart. We build with 5 agents for every human, and 100% of our code is written by AI. The barrier to "dangerously profitable solopreneur" isn't the tools anymore. It's whether you'll pick them up.

Follow the Money: A Generational Transfer in Free Cash Flow

A striking BofA Research chart (via @pequityresearch) shows where the AI money is really landing. When hyperscalers build data centers, buy GPUs, and expand power and networking, their free cash flow gets hit *first* — but the money doesn't vanish, it flows upstream to chips, memory, equipment, and power. The projection: semiconductor free cash flow rocketing toward ~$450B by 2027, while the hyperscalers (Amazon, Google, Meta, Microsoft, Oracle) dive toward *negative* territory. It's a timing gap between the spenders and the receivers in the AI capex cycle.

Explore this tweet →

🌶️ Follow the cash, not the hype. The cloud giants are torching free cash flow to build the AI world; the picks-and-shovels crowd upstream collects first. For anyone actually building on AI, the lesson isn't "go buy chip stocks" — it's that all that capex eventually has to turn into real utilization and real revenue. That's the entire game: not *spending* on AI, but *turning AI into money*. It's why we're obsessed with agents that do real work for real dollars — no blockchain required.

For the Dinner Party: ESPN Built an AI That Reads Poker Faces

ESPN's World Series of Poker coverage this year quietly added a computer-vision model that flags when a player is likely bluffing — based purely on how they move their face. On-screen, it tracks blink rate, fidgeting, gaze, mouth, and posture in real time, feeding a live "Hand Strength" readout that ranges from *Bluff* to *Monster*. An AI lie-detector, broadcast over live poker to hundreds of thousands of viewers.

Explore this tweet →

🌶️ An AI that reads your face in real time and broadcasts your bluff to the world — and it debuted on ESPN, not in a research lab. This is the quiet story of 2026: computer vision graduating from demo to primetime. Today it's poker tells. Tomorrow it's every sales call, support chat, and negotiation getting read by a model. Fun now, profound soon. (Also: pour one out for the poker face as a career skill.)

Chipp Updates

Chipp Chatter is now a live show. Every week we round up the AI news that matters — and the stuff that's just fun to know — so you're the sharpest person in the room. Get notified on YouTube →

Chipp Con: Fargo — July 30. A full afternoon of AI strategy and hands-on workshops, then the Night Bazaar. Get tickets →

*Chipp helps you build AI agents that work. Start building at chipp.ai — and get notified for the next live Chipp Chatter.*

So we're fixing that. I'm Scott Meyer, CEO at Chipp and a proud over-imbiber of AI news, and each week I'll pour you a tall glass of it. 🍸

Introducing Chipp Chatter — a fun, fast, no-homework-required YouTube live stream where we round up the week in AI. The real news, the weird news, the "wait, they built *what*?" news. In and out, smarter than you came, ready to sound like the most interesting person in any room.

What's the deal?

• ⚡ Short & snappy. We respect your time. Get the week's AI in the time it takes to reheat your coffee.
• 🗞️ The headlines that matter — and the ones that are just fun to know.
• 🍸 Built for real life. Whether you're steering a Monday standup or holding court at a Saturday dinner party, you'll have the goods.
• 🎙️ Live, so bring your questions. We'll be in the chat.

Think of it as your weekly AI cheat sheet, minus the boring parts.

Catch it live 👇

We're going live tomorrow. Hit the link, tap "Notify me," and we'll ping you the second we start.

→ [Set your reminder here](https://www.youtube.com/live/8qYkX9SGRIQ?ref=chipp.ai)

See you in the chat. Come win a dinner party.

🎥 Get a sneak peek of what happened on day one, watch the clip **here**. 👉 Want to join? Second session is Thursday! Sign up and we'll help you catch up: **The Business Agents of Change**

AI That Builds Software You Can Sell

A few themes from day one stood out.

The Three Eras of AI

How AI Is Changing Business in 2026

Most people are still using AI like a search engine. Ask a question, get an answer.

That was the first era of AI — the chatbot era — and it's great for things like customer support, where someone just wants a quick answer based on their history.

But it's only the beginning. The data backs this up: while most people use AI a few times a week for basic tasks, the companies actually investing in it are seeing real returns. Roughly three-fourths of enterprises spending on AI report positive ROI. The gap isn't access to the technology. It's implementation.

The second era arrived in late 2024 with reasoning models. Instead of predicting one answer word by word, these models generate multiple answers, review them, and pick the best one before you ever see it. That shift dramatically reduced hallucinations and let AI consider the whole picture instead of just the next word. It's the difference between a first draft and an edited one.

Now we're entering the third era: agents. With a chatbot, you ask and it answers. With a reasoning model, you tell it what to do and it checks its own work. With an agent, you tell it the *goal* — and it figures out how to get there. Instead of asking for a LinkedIn post that looks a certain way, you say "we need a marketing strategy," and the agent builds the pieces and brings them back. It acts without waiting for you to trigger every step.

That's a big deal for small teams.

Stripe recently reported that the number of solopreneurs earning over $1 million a year has doubled since ChatGPT launched. Small teams can now perform at the scale of much bigger ones — not because they hired more people, but because they gave AI the goal and got out of the way.

Understanding AI changes how you build with it

Before touching any tools, the group got a plain language walkthrough of how AI actually works. Tokens, temperature, reasoning versus chat models, and why a tighter prompt gets you a better, cheaper answer. Once you understand what's happening under the hood, you stop guessing and start building on purpose.

A simple framework for better prompts

The RIPEN framework was the biggest unlock of the day. Role, Instruction, Parameters, Example, Notes. Five pieces that turn a vague ask into a prompt that consistently gets you what you want.

Tell the AI who to be. Give it the goal. Set the guardrails. Show it an example. Add any extra context. Builders in the cohort used this to write their first working prompts in minutes, live in the session.

One AI System

The other big theme was structure. Instead of a dozen disconnected chatbots, the cohort learned how to set up a "chief of staff" agent that sits on top of specialized agents for marketing, finance, support, or whatever the business needs. The client or teammate only ever talks to one place. Everything else happens behind the scenes.

That's the difference between a fun AI experiment and something you can sell or run a business on.

Why AI costs what it costs

Scott made a point of demystifying this: AI isn't free, even when it feels that way on a $20 a month ChatGPT plan. The group walked through the actual stack, compute, the model itself, the API that connects to it, the app you're chatting in, and the channel you're using it on. Seeing the whole chain makes it easier to understand where pricing is headed, and how to price your own AI systems instead of guessing.

Privacy got the same plain language treatment. What gets used for training, what zero data retention actually means, and why some client work needs that extra layer of protection.

What a finished system looks like

Scott showed real examples already live on Chipp: a full team of AI specialists built for an orthodontics practice, and a branded chat widget running on a med spa's website that alerts the team the moment someone asks about booking. Same brain, different front door, whether that's a website bubble, a text number, or a Slack channel your clients already live in.

Seeing the finished product made it click for a lot of builders in the room.

What you leave the cohort with

Over the next three weeks, we are going to cover addition topics like:

• Building a private, branded AI system live on Chipp, built for a real client or vertical
• Hands on reps with the Alchemist, building to your own spec instead of starting from zero
• Creating a pricing and packaging plan for selling your system, not just giving it away
• Developing a case study you can actually show off

Up next in the cohort: building a Daily Ping, a personal AI that checks your email and calendar every morning and tells you what actually needs your attention.

Still time to jump in

If this sounds like where your business needs to go, you can still join the cohort and catch up fast with the recordings. Head over to The Business Agents of Change to grab your spot.

See you in the next session!

Meanwhile, solopreneurs continue to scale to unprecedented revenue levels, and the shift from chatbot to autonomous agent is showing up in the data. And most incredibly, AI is reading scrolls from Mt. Vesuvius that have never been opened!

What's happening at Chipp

We're gearing up for a busy few weeks! Here's what's coming:

Systems of Change: Private AI That Powers Your Work - July 2 at 4:30pm CT Learn how to keep your AI workflows secure and private. Register here →

Business Agents of Change - July 7 at 4pm CT Our flagship cohort for business leaders building AI-first operations. Join us →

Chipp Con: Fargo - July 30 Our first in-person gathering! Afternoon workshop + evening bazaar. Details →

AI Highlights from Around the Web

The dangerous bargain of enterprise AI

Ashwin Gopinath dropped a nuclear take on Anthropic's new Claude Tag feature. The product is being sold as collaboration, but the structural function is labor absorption. His argument: once your AI vendor becomes a shared coworker with access to Slack, tools, and company context, you're not just renting intelligence anymore—you're renting your company's operating memory back from them.

*Models can be swapped. Agents can be copied. But the memory of how your company actually works is much harder, maybe impossible, to move.*

The conversation sparked responses from Ethan Mollick and other AI luminaries, all wrestling with the same tension: these tools are genuinely useful AND potentially create deep dependency. Rent the intelligence, but own the context—or regret it later.

That's why we let all Chipp users easily export all chat history, prompts, and more. Own your AI.

The solopreneur supernova

Patrick Collison shared new Stripe Economics data showing we're in the Age of the Solopreneur. More than twice as many solo operators earned over $1M in 2025 compared to 2023. The $5M and $10M+ brackets nearly tripled!

*A one-person company with AI agents, global distribution, and production tools that would've required a 50-person team five years ago.*

This is the world we're building for at Chipp. When you can automate the coordination layer, customer service, and operational tasks that used to require hiring, suddenly "solopreneur" stops meaning "small business" and starts meaning "lean, fast, and dangerously profitable."

The chatbot era is over

New research from OpenAI economist David Holtz reveals the shift that's been obvious to anyone actually building with AI: we're moving from chatbots to autonomous agents at breakneck speed. The data shows adoption accelerating beyond engineering into operations, customer service, and business workflows.

*"Skills show promise as a way to standardize AI use in firms."*

This aligns perfectly with what we're seeing in our cohorts. The companies winning with AI aren't the ones prompting better—they're the ones building repeatable agent workflows that their teams can deploy without thinking. That's why we are so excited to continue to build out the Chipp Alchemist for fully autonomous development.

AI-native companies run different

oh hai says Chipp with our 2 FTEs!

a16z released new data showing AI-native startups are operating at a fraction of the headcount of traditional software companies at equivalent scale. When you've got agents handling tier-1 support, workflow automation, and operational heavy lifting, you don't need the same org chart.

The implication: competitive advantage is shifting from "who can hire the best team" to "who can orchestrate humans + AI most effectively." Operational leverage is getting ridiculous.

The agent-native tool stack emerges

Builder.io released Clips—a free, open-source Loom alternative designed specifically for agents. Every recording comes with APIs and metadata so AI can understand not just transcripts but everything visually in the video at any timestamp.

*"I got so sick of telling people 'don't send me feedback as Looms, I can't pass those to agents, I need text and images' that I had to just solve this once and for all."*

**This is a glimpse of the future: tools rebuilt from the ground up to be *agent-readable* by default. **The best software in 2027 won't just have an API—it'll be built assuming an AI will be the primary consumer of its output. It will be fascinating to watch startups race to offers while incumbents consider adding the capability.

AI Reads Scrolls Buried in Lava from Mt. Vesuvius

The incredible Scroll Prize read an entire scroll, without ever actually opening it!

Using AI, the scroll has been virtually unwrapped and read for the first time in modern history. This new application of AI has the potential to unlock ancient history that is literally too fragile to even touch. What a world.

*Want to build with AI like this? Join our next cohort at **chipp.ai/thetechnicalagentsofchange*

This Thursday, we're doing the opposite.

You're going to watch three people walk through the exact AI workflows they built for their businesses. Not demos. Not concepts. The actual systems they use every single day.

Join us here: https://luma.com/chipp-qlne

Kristi Steele is going to show you the AI workflow she built to help high school students navigate college applications — the one that's handling hundreds of student questions while she sleeps.

Angela Radcliffe will pull back the curtain on the healthcare AI system she designed for her clients — how it turns 20+ years of medical research expertise into an always-available resource for healthcare teams.

And Leanne Lopez Mosley is going to share how she white-labels AI to sell access to her knowledge at scale — the exact setup that helped her build a $23M+ business with an audience of under 40K.

Scott will add in additional workflows you will want to use including:

1. Research Assistant — Stay updated on news, competition, and memes with your AI assistant
2. Chief of Staff — Build a workflow to manage all aspects of your email, calendar, and daily work
3. Zoom to the Moon — Automatically create a marketing pipeline that turns Zoom transcripts into marketing materials.

Then you'll see those exact patterns in action, with real numbers and real details.

Who's Sharing Their Workflows

Kristi Steele — Founder of KC360

After a decade in college recruiting, Kristi recognized students needed more support and counselors needed better resources. So she built KC360.co, combining digital tools, virtual college fairs, and individual consultation. Now she's using AI to scale the guidance she's been giving students for years — and she'll show you exactly how it works in practice.

Leanne Lopez Mosley (aka Rich Queen)

Leanne built a $23M+ business with fewer than 40K followers by choosing smart systems over constant hustle. She's a Forbes-featured business mentor, top 1% podcast host, and the creator of Leanne AI. She's going to walk you through how she turned her knowledge into a white-label AI product her clients can deploy under their own brand — the system that lets her run a business that doesn't require her to be on all the time.

Angela Radcliffe — Author, Speaker & Healthcare AI Strategist

Angela wrote "Quantum Kids: Guardians of AI," a bestselling book that teaches elementary and middle school students about neural networks, data ethics, and prompt engineering through real-world stories. But that's just one side. Angela also brings 20+ years of healthcare, medical research, and enterprise data strategy experience from senior leadership roles at Bristol Myers Squibb. She'll show you the AI workflow she built to give healthcare teams instant access to complex medical knowledge.

What You'll Walk Away With

Most people know they *should* be using AI. Not everyone has figured out how to actually turn it on inside their business.

This workshop closes that gap.

You'll see how to deploy a private AI setup that you actually own — not another subscription tool that has access to everything you feed it. You'll watch real people demonstrate how they branded it, integrated it with their existing software, and turned on privacy protections that ChatGPT and Claude on their own will never give you.

You bring the knowledge of what your business actually needs. Chipp handles the rest.

Join Us Thursday

It's free. It's live. And you'll walk away with workflows you can deploy by Friday.

Thursday, June 25 11:30 AM to 1:00 PM CST

[Register here](https://luma.com/chipp-qlne?ref=chipp.ai)

No fluff. No theory. Just three people showing you exactly what they built and how you can build the same thing.

This week in AI:

• Developers are building entire products while on customer calls
• AI companions are eating dating apps for lunch
• The hype around AI tokens is meeting cold reality.

Meanwhile, AI is getting personal with custom learning paths that adapt to how you think...Oh, and Midjourney just casually announced they're building medical scanners that are 100X faster than MRIs. With a team of 9.🤯

On the Chipp side:

• Kicking off Systems of Change workshops starting June 25th
• Launching the next Business Agents of Change cohort on July 7th
• Hosting Chipp Con in Fargo on July 30th.

AI Highlights from Around the Web

Developer Builds Autonomous Product During Customer Call

Todd Saunders just casually dropped this: while on a call with a customer, he fired up Cursor (an AI coding tool) and built an entire autonomous building system that actually works. Not a prototype. Not a proof of concept. A working product. During. A. Call.

Explore this tweet

🌶️ The meeting was the build time. We've crossed into a reality where customer discovery and product development happen simultaneously. Software velocity isn't measured in sprints anymore—it's measured in conversations. At Chipp, we're already operating this way. If you're still planning two-week sprints, you're already behind.

The 14 Levels of AI Transformation (And Where You Actually Are)

Alex Lieberman mapped out the entire AI transformation journey from "I tried ChatGPT once" to "My AI employees run my business." It's a brutally honest roadmap that starts at Level 0 (AI skeptic) and goes all the way to Level 14 (AI-native operating system). Most people think they're at Level 7. They're at Level 3.

Explore this tweet

🌶️ If you're reading this, you're probably somewhere between Level 4 ("I use ChatGPT regularly") and Level 8 ("I've built custom GPTs"). The gap to Level 12+ ("AI agents handle complex workflows autonomously") isn't technical—it's mental. The tools are here. The question is whether you're willing to let go. Our cohorts are designed to push you up this ladder fast.

Americans Now Spend 2x More Time With AI Companions Than Dating Apps

The data just dropped: Americans are spending twice as much time talking to AI companions as they are on dating apps. Not because dating apps are declining—they're not. AI companion usage is just exploding. People are forming genuine relationships with AI. Daily check-ins. Emotional support. Life advice.

Explore this tweet

🌶️ This isn't about loneliness—it's about availability. AI companions respond instantly, remember everything, never judge, and are optimized for your exact communication style. Humans can't compete with that level of attentiveness. The question isn't whether this is healthy (that ship has sailed). The question is: what does this mean for every other relationship-based business? Therapy, coaching, consulting, customer support—all of it is about to get disrupted by entities that are infinitely patient and infinitely available.

Reality Check: AI Token Economics Don't Add Up (Yet)

Citadel just poured cold water on the AI token hype. After deep analysis of AI agent economies, their conclusion: the math doesn't work yet. Transaction costs are too high. Token velocity is too unpredictable. The infrastructure for AI-to-AI payments exists in theory but breaks down in practice. It's the equivalent of trying to build e-commerce before SSL.

Explore this tweet

🌶️ Good. The AI token casino needed this reality check. While everyone was speculating on "agent coins," the actual builders were focused on making AI agents that solve real problems for real money—regular USD. Chipp processes millions of AI interactions. Not one of them requires a blockchain. Build value first. Tokenize later. Or never. Most ideas don't need tokens; they need customers.

AI That Learns How You Learn

Matt Pocock just introduced a `/teach` skill that completely changes how AI helps you learn. Instead of generic explanations, the AI asks about your learning style, adapts its teaching method to match, and builds a personalized curriculum based on what you already know. It's like having a tutor who studies you as much as you study the subject.

Explore this tweet

🌶️ This is where AI education gets interesting. Generic learning is dead. Why would you learn from a one-size-fits-all course when you can have a teacher who adjusts in real-time to your confusion, connects concepts to things you already understand, and never gets tired of your questions? This is the future of every course, every tutorial, every training program. At Chipp, we're already building agents that do this for customer onboarding. The gap between "learning about a tool" and "being productive with a tool" just collapsed to minutes.

Midjourney Just Pivoted to Healthcare (With a Team of 9)

Wait, what? Midjourney—yes, the AI image generation company—just announced they're launching "Midjourney Medical." They've built a full-body scanner that's 100X faster and 10X cheaper than an MRI. It uses sound waves while you're submerged in water. No radiation. No giant magnets. Just 60 seconds and you get detailed 3D images of your entire body. And they're planning to scale to 50,000 scanners capable of a BILLION scans per month. The team building this? Nine people. NINE PEOPLE.

Explore this tweet

🌶️ This is what happens when AI-first companies realize they're not in the "image generation" business—they're in the "reality manipulation" business. Midjourney spent years training models to understand spatial relationships, lighting, anatomy, and physics. Turns out that's exactly what you need to process ultrasound data into 3D medical imaging. While healthcare companies were protecting their moats, a creative AI company just casually dropped a 100X improvement in diagnostic imaging. The pattern here isn't disruption from adjacent markets—it's AI companies realizing their core tech is way more generalizable than anyone thought. What other "creative tools" companies are secretly sitting on healthcare breakthroughs? What else can these models do that no one's tried yet?

Chipp Updates

Systems of Change: Private AI That Powers Your Work

We're launching a new workshop series on building private AI that actually integrates with your work. Two sessions starting June 25th and July 2nd at 4:30 PM CT. Learn how to deploy AI agents that work inside your systems, not outside of them.

Register here.

Business Agents of Change: July Cohort Now Open

The next cohort of Business Agents of Change kicks off July 7th at 4:00 PM CT. Four weeks of hands-on training where you'll build four working agents: marketing content, lead scraping, 24/7 voice support, and a custom agent for your specific business needs.

This isn't theory. You'll leave with agents running in production.

Join the cohort.

Chipp Con: Fargo - July 30th

We're hosting Chipp Con in Fargo on July 30th. A full afternoon of AI strategy, hands-on workshops, and real implementations from Chipp builders. Then we're staying for the Night Bazaar (Fargo's best summer event—you don't want to miss it).

Get tickets for Chipp Con. Join us for Night Bazaar.

Week in Review: What We're Building

At Chipp, we're building with 5 agents for every 1 human. 100% of our code is written by AI. Every feature, every fix, every improvement. We're not just building an AI platform—we're building *with* AI as a core team member.

Want to see how we do it? That's what our cohorts are for. Join us.

---

*Chipp helps you build AI agents that work. Start building at **chipp.ai** or **join our next workshop**.*

• Peter Thiel just invested $140M in floating AI data centers because America's power grid can't handle AI's appetite • Visual data shows AI's real economic impact across four key metrics • Cloudflare laid off 20%+ of its workforce despite record growth — CEO says AI is coming for "measurers," not builders • Eli Lilly published results on a one-shot gene therapy that permanently fixes cholesterol (keeping things interesting beyond AI) The theme this week: AI infrastructure is hitting physical limits, job displacement is accelerating, and we're seeing hard data on who gets cut first. Meanwhile, other fields are having their own 1450 moments.

On the Chipp side:

• 🎪 ChippCon Fargo is coming July 30! Full day of workshops, demos, and "show what you built" sessions, followed by a Night Bazaar after-party. Grab your spot here

• 📺 New on YouTube: Autonomous Development in Action workshop — watch how we're rebuilding Chipp with AI agents writing code, testing in production, and self-healing bugs. Watch the recording

• 🗓️ Next workshop drops in early June. Check the full calendar

AI Highlights from Around the Web

Peter Thiel Bets $140M on Floating AI Data Centers

Peter Thiel is leading a $140 million investment in Panthalassa, an Oregon startup building giant steel orbs that float in the ocean to run AI workloads. Why? America's power grid can't handle AI. In the biggest power market (NJ to Illinois), the cost of reserving future power jumped from $29 to $329 in two years — more than 10x higher. If you order a transformer for a data center, you now wait four years. Almost half of America's planned AI data centers for this year have been cancelled or delayed. The grid cannot handle them. Panthalassa's solution: Waves push water through internal channels to spin turbines, powering AI chips right there on the platform. Cold seawater cools them for free (Microsoft proved this works — they sank 864 servers in a steel tube off Scotland, used zero freshwater, and saw 8x fewer breakdowns). And nobody fights you in the open ocean.

**Read the post.**

The Impact of AI in Four Charts

Marc Porter Magee shared visual data showing AI's economic impact across education, workforce, productivity, and adoption. The charts make the scope clear: this isn't hype, it's measurable change happening across multiple sectors simultaneously. **Check the post.**

Cloudflare CEO: AI Is Coming for "Measurers," Not Builders

Cloudflare just laid off 20%+ of its workforce — despite posting record revenue growth, strong free cash flow, and adding customers faster than ever. CEO Matthew Prince's thesis: AI doesn't replace builders or sellers. It replaces measurers — middle managers, auditors, operations teams, and most of marketing. The vast majority of cuts were measurers. Middle managers got consolidated because AI allows more direct reports per manager while still measuring and mentoring teams effectively. Operations functions merged into one group using AI for specific expertise. Marketing teams (which Prince says are "teeming with measurers") saw significant cuts. Meanwhile, Cloudflare hired 1,111 paid interns this summer from nearly 1 million applicants. All builders or sellers. All AI-native.

**Check the full tweet.**

One Shot, Permanent Fix: Gene Therapy Arrives for Cholesterol

Eli Lilly published a trial in NEJM showing a single IV infusion of a base editor (VERVE-102) that rewrites one DNA letter in your liver cells — shutting down PCSK9 production the way it's already broken in ~400 genetic "lottery winners" found in a Texas study. Result: 62% drop in LDL cholesterol. 88% suppression of PCSK9. Effects holding 18 months and counting. No serious adverse events. The gap between people who won the genetic lottery and everyone else just got an engineering solution. **Read tweet.**

That's it for this week! If you're building something with Chipp and want to share it at ChippCon or in a future workshop, hit reply or DM us. We want to see it. – Scott & The Chipp Team

Understanding autonomous development requires understanding context engineering. Every agent session exists inside a context window—that's the agent's entire world. It contains the Claude.md system prompt, prior tool results, file contents, user prompts, and the results of every tool call the agent makes. When an agent reads a file or runs a shell command, the result gets appended to this context. The agent uses that information to decide what to do next.

AI naturally creates what we call "demo-ware"—code that's about 90-95% correct. It looks good in a screenshot but breaks under real use. Crossing that last 5% to production-quality code requires fast feedback loops. This is the critical insight: all tool calls must execute in under one second locally and under one minute in production. Without that speed, agents timeout, hallucinate, or give up before they can verify their work.

The Stack That Made It Possible

We killed our entire tech stack and started over. The old setup—Next.js with Vercel—gave us 8 to 15 second local compile times, sometimes stretching into minutes. AI agents would time out waiting for changes to load. When they couldn't verify their edits, they hallucinated. "Browser MCP is down, so I'll assume this is good" became a common refrain in the logs. That's not autonomy—that's guesswork.

The winning stack became Svelte for the client (high-performance with sub-one-second recompiles via Vite), Deno for the server (native TypeScript with no transpilation, which means cleaner stack traces), Postgres with pgvector (vectors stored next to data instead of in a separate vector database), and Cloudflare for global CDN, bot protection, and instant splash page loads.

The difference is night and day. In the Next.js world, a 12-second compile cycle stretches a simple fix to 9 minutes and produces three garbage edits. With Svelte and Deno, the same fix takes 15 seconds and produces one clean commit ready to merge.

Local Verification: How AI Agents See What They Built

Autonomous development depends on agents being able to see and verify their own work. We use Browser MCP—Chromium controlled via the Chrome DevTools Protocol—to give agents eyes and ears into the running code. The agent can navigate to a local URL, open tabs, take screenshots, pull console logs to catch client-side errors, inspect network requests, check element styles, and reload the browser to verify changes. On the server side, Deno logs provide server-side verification.

Here's a real example: fixing a typo in two minutes with seven tool calls. The agent grepped for the "SAV" button and found 14 matches, but only one was the actual bug. It navigated to the settings page in the browser, took a screenshot confirming the "SAV" button existed, edited the file to add the missing "E", reloaded the browser, took another screenshot confirming "SAVE", checked the console logs for errors, and then committed and pushed the fix. Two minutes, seven tool calls, one clean fix.

Self-Healing in Production: When Bugs Ship Anyway

Even with a five-stage pipeline—research, plan, implement, code review, documentation—and agents reviewing other agents' code, some bugs still slip through. Some bugs only happen at scale and aren't reproducible locally.

That's where self-healing comes in. Production errors feed into Grafana Loki, our self-hosted error monitoring system. When an error occurs, the AI agent gets paged automatically. It reproduces the error, fixes it, and ships the fix—often before anyone wakes up. Hunter used to get paged at 3 AM for production incidents. Now he sleeps through them.

Testing in production is scary, and most companies won't do it. But we're fighting for survival, and our bias is toward speed: fix things rapidly instead of trying to prevent everything upfront. That's the edge most companies won't take.

MCP: The Secret Sauce for Constraining AI

There's a lot of "MCP is dead" discourse on social media right now—classic mob mentality. The reality is that MCP is essential for autonomous development. Here's why: AI can only be autonomous if you constrain it.

We built custom MCP tools specifically for Chipp's stack. Our agents can trigger WebSocket events, simulate webhooks, grant billing credits for testing, and inject errors to verify error handling. The most powerful tool is App State: it serializes the entire Svelte store state and sends it directly to the model. Instead of guessing application state from a screenshot, the agent knows exactly what's happening.

Opinionated stacks win in the autonomous world. Cursor and Claude Code optimize for every possible tech stack, which means a human still needs to be in the loop to guide decisions. Alchemist AI optimizes for one stack—ours—which enables full autonomy.

What This Means for You

For non-technical decision-makers, this is the end of "we need more headcount" as an excuse. There's no backlog, no ticket system, no sprint planning. The project manager role disappears because everything ships immediately.

For technical teams, this doesn't mean firing everyone. It means keeping your best engineers—the ones who can quote source code from memory—and turning them into force multipliers. Non-technical people can now build. Scott, our co-founder, has no deep knowledge of the source code, but he ships features every week.

This is the accessibility revolution. You don't need to come from wealth. You don't need to attend Stanford. You don't need to live in Silicon Valley. The capital requirements to build software just dropped dramatically.

What's Next: Alchemist AI and Autonomous Development as a Service

We're not keeping this system to ourselves. Alchemist AI is the vibe coding platform we built to run autonomous development, and we're now offering ADAAS (Autonomous Development as a Service) on a waitlist basis.

On July 30, we're hosting Chipp Con in Fargo where we'll announce more products and show you what's coming next. This is just the beginning.

In six months, we'll be six months ahead. In a year, most development teams will run this way. Now is the time to learn autonomous development.

Want to see this in action?

We're opening up early access to Alchemist AI and our autonomous development stack. [Join the waitlist] (http://adaas.dev), or meet us at Chipp Con Fargo in July to see it live.

That's not a thought experiment. That's Chipp, as it exists right now. For the past three months, every bug report, every feature request, every edge case has been handled by an autonomous cluster of coding agents. No human review gate. No pull requests waiting for approval. Just software building itself, straight to production.

We've been calling it ADaaS — Autonomous Development as a Service.

And on Wednesday, May 27th at 9:00 AM Central, we're showing you exactly how we built it. More than that: we're giving you the code to use for yourself.

The 1450 Moment

Software is in 1450 right now.

The printing press got invented in 1450. A century later, the entire economic and political structure of Europe was different. Not because the press changed things directly, but because distributing knowledge had been pulled apart from producing it. Once those two came apart, every system built on their coupling came apart with it.

For fifty years, producing software and running a software business have been welded together. To ship a feature, you needed someone (usually a credentialed someone) to hand-write the lines. Every SaaS price tag is ultimately a way of paying down the cost of the team that wrote the code.

Autonomous coding agents are pulling those two halves apart right now. The companies that figure this out early will have an unfair advantage. The window where this is a contrarian take is closing.

What Changed

We don't write code anymore. Hunter, our CTPO, and I have eight Claude Code sessions running in parallel at any given time, shipping features straight to production. Not "AI-assisted commits." Not pull requests. Production.

We deploy 20 to 30 times a day. The autonomous cluster has been running for two months. It's a normal Tuesday.

Three things compounded to make this real:

1. Models capable enough to ship code (Opus 4.6 was the inflection)
2. A tool surface rich enough to verify (browsers, logs, screenshots, MCP)
3. Context engineering — the discipline we had to learn the hard way

Capable model + rich tool surface + learned discipline. That's autonomous software development. That's what Hunter will teach you.

The Economics Flip

Before: A feature costs you one engineer-week. The engineer gets paid whether the feature is valuable or not. To run a software business, you stockpile engineer-weeks.

After: A feature costs a few dollars in API tokens and the time it takes you to describe it. Most of our changes at Chipp cost between $2 and $4 in token spend, end to end. A senior engineer's hourly rate, fully loaded, is north of $150.

Do the math. The build cost just collapsed.

This isn't "AI replaces engineers." It's "AI replaces the bottleneck of engineer time." Engineering judgment doesn't get cheaper. The labor of typing the code does.

Tiny TAMs become buildable. SaaS unbundles. Every engineer becomes a manager — not in headcount, but in cognition. The barrier was always the cost of the build, not the size of the market.

What You'll Learn (And Get)

This hands-on workshop led by Hunter Hodnett will show you:

• The architecture: How we built the autonomous cluster (research agent, implementation agent, code-review agent, documentation agent, deploy agent)
• Context engineering: The discipline that makes autonomous coding reliable, not chaotic
• The verification loop: How the cluster knows when it broke something and how it fixes itself
• Production deployment: How to ship straight to prod without human review gates
• The code itself: You're walking away with the actual system we use

This will be technical. This will be futuristic. You're going to love it.

Why Now

We expect that we are six months ahead of being six months ahead.

That's not arrogance — it's pattern recognition. The inflection happened. Most people haven't noticed yet. If you're reading this, you probably have. The question isn't "Will autonomous development happen?" It's "Do you want to be early or late?"

The next decade isn't about coding agents. It's about everything that comes apart once code stops being scarce.

Be early.

📅 Autonomous Development in Action: Software that builds Software

When: Wednesday, May 27th at 9:00 AM Central Led by: Hunter Hodnett, CTPO at Chipp Format: Hands-on technical workshop Cost: Free

**Register on Luma →**

*P.S. — If you're building something and want to talk about autonomous development before the workshop, **reach out**. We're happy to share what we've learned.*

Here are the highlights from the week that was in AI and our spicy takes on what it actually means. 🌶️

This week in AI:

• Four quiet charts show AI already reshaping books, courtrooms, music, and science
• Benedict Evans’ annual “AI Eats The World” deck declares the models are commoditizing — value moves up the stack
• “Harness engineering” emerges as the skill behind actually-useful AI agents
• The outbound playbook every $1M YC founder is secretly running (spoiler: it’s all distribution)
• Meta’s reported $14 billion hire finally speaks — and calls his first model “an appetizer”

On the Chipp side:

• Weekly hands-on workshops are live for builders who want to launch and monetize AI agents
• Featured sessions: Chipp Platform Training and How to Sell AI: Build & Monetize Your Own AI Platform
• Save your seat on Luma: https://luma.com/chippdotai?ref=chipp.ai
• Want deeper support? Join the Agents of Change cohorts: https://chipp.ai/theagentsofchange?ref=chipp.ai

AI Highlights from Around the Web

Four Charts That Show AI Already Changed Everything

Marc Porter Magee shared four charts tracking what's surged since ChatGPT launched: weekly e-book releases on Amazon, the share of self-represented federal lawsuits, AI-generated music uploads, and scientific papers submitted to ArXiv. Each line bends sharply upward right around late 2022. It's a quiet but undeniable picture of AI seeping into books, courtrooms, music, and research all at once.

*If image doesn’t load, view tweet: **https://x.com/marcportermagee/status/2057066310765289545?ref=chipp.ai*

*The debate over whether AI is “real” is over — the charts already moved. The only question left is whether a flood of AI-generated books, lawsuits, and papers makes the world better or just louder.*

Benedict Evans' Annual Deck: The Models Are Commoditizing

Matt Harney flagged Benedict Evans’ new 79-slide “AI Eats The World” presentation, the tech world’s most-screenshotted annual ritual. The provocative thesis: chat is a terrible interface, the labs can’t build every app themselves, and as models commoditize, the real value moves up the stack to whoever owns the workflow. He also maps a fresh semiconductor investment cycle and consumer usage that’s “a mile wide and an inch deep.”

*If image doesn’t load, view tweet: **https://x.com/SaaSletter/status/2056154952389808398?ref=chipp.ai*

*“Models are commoditizing and value moves up the stack” is the most important sentence for anyone building on AI. Translation: stop worshipping the model. The money lives in the boring layer that turns a model into something a business will actually pay for.*

“Harness Engineering” Is the Skill Nobody Was Hiring for Six Months Ago

Vaishnavi pointed to a free site teaching “harness engineering” — the craft of building the scaffolding (context, memory, agent loops, evals) that makes AI coding agents actually useful. It blew past 4,000 likes because it names a skill that suddenly matters: the model is a commodity, but the harness around it is where the real leverage lives.

*If image doesn’t load, view tweet: **https://x.com/_vmlops/status/2055887618303570151?ref=chipp.ai*

*A year ago “prompt engineer” was the meme job. Now the real work is engineering the harness — the context, memory, and guardrails around the agent. The people who learn this now are writing their own job descriptions for 2027.*

The Outbound Playbook Every $1M YC Founder Is Quietly Running

Finn Mallery distilled what the current YC founders crossing $1M ARR all have in common — the exact same outbound motion. Build lead lists with tools like Clay, run a LinkedIn connect-and-DM sequencer at 200 connects a week, keep DMs to two warm sentences, post daily, and get good at AEO (answer engine optimization). Twenty focused hours a week, and the demos start booking.

*If image doesn’t load, view tweet: **https://x.com/fin465/status/2055137077868814804?ref=chipp.ai*

*Notice that none of this is “build a better product.” Distribution is the moat now, and AI just made it cheap enough for a solo founder to run an enterprise-grade outbound machine. If you’re waiting for the product to sell itself, someone running this playbook is already eating your lunch.*

Meta's $14 Billion Hire Finally Talks

Ashlee Vance landed the first interview with Alex Wang since Meta reportedly paid $14 billion to pry him from Scale AI and put him in charge of its AI turnaround. Wang opens up about rebuilding a frontier lab from the inside, the all-star team Zuckerberg assembled (Friedman, Gross, Zhao), and their first model, Muse Spark — framed, tellingly, as “an appetizer, not the entrée.”

*If image doesn’t load, view tweet: **https://x.com/ashleevance/status/2054907581462987109?ref=chipp.ai*

*$14 billion for one person is either the clearest sign that AI talent is the scarcest resource on earth, or the clearest sign we’re deep in bubble territory. Probably both. And when a company calls its flagship model an “appetizer,” maybe manage your expectations about the main course.*

Chipp Updates

• Upcoming workshops: https://luma.com/chippdotai?ref=chipp.ai
• Agents of Change cohorts: https://chipp.ai/theagentsofchange?ref=chipp.ai
• Recent Chipp content: https://chipp.ai/blog?ref=chipp.ai
• YouTube: https://www.youtube.com/@chippai?ref=chipp.ai

Claude on its own (even Claude 4.6, even Claude with full tool use, even Claude with MCP and a perfect `CLAUDE.md`) has no concept of "this task should have been done an hour ago" or "I've made the same mistake three times in a row." It doesn't quit. It doesn't get bored. It will burn your entire token budget if you let it.

The bash harness is the part of the cluster nobody writes blog posts about, because bash isn't sexy. It's also the part that makes the whole thing reliable enough to push to production. This is that post.

The framing

Cline put it best, in a documentation update I read after building most of our harness: *"An autonomous agent without a bash harness is a brilliant intern with no manager, no deadline, and an unlimited API budget."*

That's the threat model. The model is the intern. The bash harness is the manager.

The intern is genuinely good. The intern can do work that would take a human three days. The intern can't *self-supervise*. If the intern wanders into a corner of your codebase that has no test coverage and decides to refactor it from scratch, the intern won't notice that's not what you asked for. If the intern can't figure out how to fix a bug, the intern won't say "I give up." They'll keep trying, with progressively more elaborate workarounds, until something stops them.

The bash harness is what stops them. Specifically, it does six things.

What the harness does

1. It runs Claude headlessly

The headline command is `claude -p "your prompt here"`. The `-p` flag puts Claude Code in non-interactive (headless) mode. Instead of opening a chat UI, Claude runs the prompt to completion, streams its work to standard output, and exits when done.

We pair `-p` with `--dangerously-skip-permissions`, which tells Claude to stop asking for confirmation before every tool call. In an interactive session, you want those prompts. In a headless session that needs to run unattended, you don't. (The `--dangerously-` prefix is honest. Skip permissions and the agent can do real damage. The bash harness is what makes this safe.)

The combination (headless mode plus skip permissions) is the atomic primitive of every autonomous coding system. If you only learn one thing from this whole series, learn that. Without it, the model is a chatbot. With it, the model is a worker.

2. It enforces a wall-clock timeout

If Claude has been running for two hours, something is wrong. Either it hit a class of problem it can't solve, or it's looping, or the task was wildly under-scoped. Either way, killing it is the right move.

Our harness wraps `claude -p` in a `timeout 7200` call (2 hours, expressed in seconds). When the timer hits, the process is killed, the work-tree is captured for forensics, and the harness logs a failure ticket for human review.

The number isn't sacred. We started at 8 hours, dropped to 4 when we realized we were paying for runaway sessions, and settled at 2 because every legitimate task we've measured fits well under that. Pick a number that's longer than your slowest legitimate task and shorter than "I will go bankrupt."

3. It detects hangs

Claude can be running but not making progress. Sometimes it gets stuck on a tool call: a Docker container that takes forever to start, an MCP server that hangs, an HTTP request to a slow third party. The wall-clock timeout catches this eventually, but you don't want to pay for two hours of nothing.

The harness watches the agent's stdout for *tool call activity*. Every meaningful turn produces a tool call entry. If five minutes pass with no tool call output, the harness assumes the agent is stuck and kills it. The threshold is a tunable. We started at 2 minutes and bumped to 5 because some legitimate operations (large grep on a big codebase, slow MCP servers) take longer.

4. It bans dangerous patterns

The agent will, occasionally, output a command that would do irreversible damage. Not from malice. From training data. Real examples we've caught:

• `git reset --hard HEAD~5` (when the agent gives up and tries to wipe its work)
• `git push --no-verify` (when CI fails and the agent decides to bypass the check)
• `rm -rf /` (rare, but yes)
• `--force-overwrite` flags on database migrations

The harness greps the agent's command stream for known-bad patterns. When it sees one, it kills the session and logs a ticket. We curate this list as we discover new ones.

This is defense-in-depth. The model *shouldn't* output these commands; we have rules in `CLAUDE.md` against most of them. But the model occasionally will, and "shouldn't" is not the same as "won't." The harness is the airbag.

5. It cleans up after the agent

Each agent session runs in its own *git work-tree*: a separate checkout of the repo, isolated from every other agent's work. When a session ends, the work-tree might contain uncommitted changes, half-finished branches, leftover processes (dev servers, browser instances, MCP servers).

The harness runs a cleanup pass. It checks the work-tree for uncommitted changes (and either commits them with a salvage marker or stashes them for forensics, depending on session outcome). It runs `pkill` on any orphaned processes that started during the session. It deletes the work-tree if the session succeeded, or archives it if the session failed.

Without this, every failed session leaves debris. After a hundred sessions, your `~/code/worktrees` directory is a graveyard. Cleanup is unglamorous and load-bearing.

6. It enforces the push step

When a session succeeds, the agent should push its commit to a target branch. Sometimes the agent forgets, or mis-commits, or commits without pushing. The harness checks the work-tree state at the end of every session: are there committed-but-unpushed changes? If yes, the harness pushes them. Are there changes the agent forgot to commit? If yes, log a failure. The agent didn't finish.

This is the final guardrail. The whole pipeline ends with code in production. If the agent's work doesn't end up there, the entire run was wasted. The harness *makes sure* the work lands.

Why bash, specifically

I wrote the first version of the harness in TypeScript. It was elegant. It had types. It also took ten times as long to debug as the bash version that replaced it.

Bash is the right language for this. Three reasons:

1. The harness wraps a Unix process, and bash is the language for wrapping Unix processes. Subprocess management, signals, file descriptors, timeouts, pipes. All of this is expressed concisely in bash and verbosely in everything else.
2. The harness has to be debuggable in production. When something goes wrong, you SSH to the machine and read the script. Bash scripts are visible. There's no compilation step, no module resolution, no runtime to set up. You can audit the entire harness in fifteen minutes.
3. The harness should be boring. It's the deterministic core of an otherwise non-deterministic system. The fewer abstractions, the fewer dependencies, the better. Bash has no dependencies. It will work on any Linux box, with no setup, in five years.

The harness is currently 312 lines of bash. Most of those lines are comments. The actual logic is short.

Each agent gets its own work-tree

A note on parallelism, because it's the part that surprises people.

We run eight agents at a time on my laptop. They don't share a working directory. They don't share a database. They don't share dev server ports. Each agent has:

• Its own git work-tree (a checkout of the repo at a separate filesystem path).
• Its own dev server, on a unique port (5180-5187, parameterized by worker slot).
• Its own browser MCP target (Chromium instance, also on a unique port).
• Its own log stream, prefixed with the worker slot for easy filtering.

The agents are completely isolated. Two agents working on conflicting changes won't step on each other. They're in different work-trees, on different branches. When they push, the push happens on the same remote, and any merge conflicts are resolved by the deploy pipeline (or, in the rare case where they're not auto-resolvable, surfaced as a failure ticket).

This is the part of the architecture I was most nervous about and it's worked the best. Eight independent workers running in parallel turns out to be the right level of concurrency for one developer's machine. Going higher saturates my Mac's resources. Going lower means tickets sit in queue.

The lesson

Every autonomous coding system you build will fail in ways the model can't recover from. The model is good at writing code. It's bad at noticing it's wasted three hours, bad at stopping itself, bad at cleaning up its mess. The bash harness is the part of the system that's good at those things.

Without it, you have a hobby project. With it, you have something you can leave running overnight.

This is the unglamorous core of every production-grade agentic system I've seen. Cursor has one (their internal harness for background agents). Devin has one. We have one. If you're building your own cluster, you'll build one too. Mine will save you a few weeks of mistakes.

In the final post of this series, I'll get into distillation, the part that turns short-term Anthropic-dependence into long-term independence, and the part the AI labs are quietly going to lobby against. If you've followed this series this far, distillation is the post that matters most for your business in 2027.

If you'd rather skip the year of building and use a cluster that already has all of this, join the Alchemist waitlist.

If you're going to build a real business on top of agentic AI, you need to understand the platform risk you're taking. And you need to understand the move that mitigates it (*distillation*) because it's both the long-term moat for AI-native businesses and, increasingly, the most contested issue in AI policy. The AI labs are about to start lobbying to make distillation harder, slower, or illegal. The reasons they'll give will sound noble. The actual reasons are about preserving their monopolies. Pay attention to this fight.

This post covers what distillation is, why it matters, what we've learned doing it, and why the regulatory dimension is the part you should be loudest about.

The platform risk

Right now, in early 2026, Anthropic has the best coding model. By a meaningful margin. It's not close.

If you're building an autonomous coding system, you use Claude. Cursor uses Claude under the hood for most of their work. Cognition (Devin) uses Claude. We use Claude at Chipp. The companies advertising "Claude alternative" or "Gemini-powered" coding agents are quietly using Claude when their customers care about output quality.

That dominance is real and it's a problem.

Right now, Anthropic prices their Claude Max plans at \$100-\$200 per month with very generous usage caps. They subsidize this: every Claude Max session costs them more in compute than they're charging. They do this because they're capturing the market, training on the data, and improving their models faster than anyone else. They're playing the Uber-rides-cost-\$3 phase of the platform game. We benefit.

Eventually that ends. Anthropic, or the company that buys them, has to stop subsidizing. Prices go up. Rate limits get tighter. Specific use cases (say, "running thirty parallel agents on a single machine") get reclassified as enterprise-tier and priced accordingly. We saw the first sign of this when Claude Code quietly moved from the Pro plan to the Max plan in April. That's not the last move.

If you've built your business on Claude, every move Anthropic makes is a move against your margin. Eventually they'll capture so much of the value you create that the only way out is to cut a deal. That's not a hypothesis. That's how every platform plays out, every time.

The defense is distillation.

What distillation is

Distillation, in plain language: take the frontier model's outputs and use them as training data for a smaller, cheaper model that you own.

In a normal training run, you'd train a model from scratch on raw data: the entire internet, code from GitHub, documentation. That takes hundreds of millions of dollars and 18 months. Distillation skips most of that. You start with an open-source base model: a smaller, less-capable model someone else has already pre-trained at vast expense and released for free. Then you fine-tune that model on a curated dataset of high-quality input/output pairs. Each pair is a question or task, and the answer the frontier model gave to it.

The smaller model learns to mimic the frontier model's behavior on the specific kinds of tasks you fine-tune for. It doesn't get smarter at everything. But it gets *much* smarter at the slice you trained for. For a narrow, specialized use case (say, autonomous coding in your specific tech stack), a distilled model can hit 60-90% of the frontier model's quality, at a fraction of the inference cost, on hardware you control.

This is how DeepSeek matched OpenAI's GPT-class models for $5 million in training compute, against the billions OpenAI spent. They distilled. The Chinese open-source community is pioneering this technique, partly because it's an effective way to compete without matching American capital expenditure, and partly because they've correctly identified that the frontier-model arms race is a winner-takes-most game they can't win head-on.

What it costs to distill

I've been distilling our autonomous coding cluster's outputs for the last few months. The honest scoreboard:

• We've spent about $2,500 on training so far, across a few experimental runs.
• Our best distilled model, based on Qwen 2.5 14B, performs at about 63% of Claude Opus 4.6's quality on our internal benchmarks.
• Inference cost on the distilled model is roughly 1/100th of inference on Opus. About \$0.04 per ticket vs \$4 per ticket.

63% sounds bad. It's not. Most of what an autonomous coding cluster does is not the frontier of model capability. It's the routine work. Reading code, writing CRUD, applying conventions, running tests. A 63% Opus model that costs 1% as much will handle 80% of the tickets. Frontier models can handle the remaining 20%.

The economics of "cheap distilled model handles routine tickets, frontier model handles edge cases" are very different from "frontier model handles everything." The former is sustainable at scale. The latter is a bet that Anthropic stays charitable.

The distillation process itself is straightforward in shape and difficult in detail. You collect training data: every prompt your frontier model has answered, every tool call sequence, every successful output. You curate it (this is the hard part; bad data poisons the training). You pick a base model and a fine-tuning approach. You run the training. You evaluate. You ship.

We use Hugging Face for the model hosting and the training infrastructure. The base models we've experimented with most are Qwen (Alibaba's open-source family, currently the strongest open coding models) and Llama (Meta's open family). We use supervised fine-tuning (SFT), the simpler of the two main approaches. The other approach, preference-based methods like DPO and GRPO, requires far more data and is what DeepSeek used to match GPT. SFT is the entry point. The amateur approach. It works.

The training data is the asset. We've recorded every successful autonomous run on our cluster: every prompt, every tool call, every output, every outcome label (did this fix actually solve the issue?). After a few months, we have a dataset that's specific to our use case in a way no public dataset is. That's the moat.

Save your training data now

Here's the operational lesson: start saving your training data today, even if you're not training yet.

If you're using Claude Code interactively, your chat history is on your machine. Move it to a stable location. Back it up. Tag the conversations by outcome: did the work ship? Did it break? Did you have to re-prompt? Outcome labels are what makes training data valuable, and outcomes are easy to capture in the moment and impossible to reconstruct after the fact.

If you're building a product on Anthropic's API, log every request and response. Tag the requests by feature area, by use case, by outcome. Store the logs in a database, not a logfile. You will want to query them.

If you're operating a SaaS that uses LLMs, your customers' interactions with your AI features are training data. Make sure your terms of service give you the right to use that data for model improvement, and make sure the data is being captured in a usable format.

Three years from now, when distillation is the obvious move, you'll either have years of high-quality training data or you'll have to start from scratch. The decision to capture the data is one you make now. The decision to train on it is one you can defer.

Why this fight is coming

The major AI labs do not want you to distill. Distillation breaks their business model. If everyone can take the outputs of the frontier model and train cheaper, comparable models for narrow use cases, the labs lose pricing power.

Their playbook, which is starting to surface in policy discussions, has three moves.

Move 1: redefine distillation as theft. Rename it "model output exfiltration" or "intellectual property circumvention." Argue that training one model on another model's outputs is a copyright violation. (The legal argument here is weak, since model outputs are not copyrightable in the same way human writing is, but the labs have a lot of lobbyists.)

Move 2: lobby for export controls. Argue that distilled models are a national security risk because foreign adversaries can use the technique to catch up with American AI capability. Get a regulation passed that requires labs to add clauses to their terms of service prohibiting distillation, with criminal penalties for violation. (DeepSeek will be invoked. The implication will be that all distillation is geopolitically dangerous. The actual concern is monopoly maintenance.)

Move 3: technical countermeasures. Watermark model outputs in ways that distilled models will inherit, then sue anyone whose model produces watermarked-output-style behavior. (Technically hard. The labs are trying anyway.)

If you care about a competitive AI ecosystem (and you should, because monopolies are what drive prices up and innovation down) distillation is the single most important policy issue to follow. Pay attention to who's introducing legislation. Pay attention to who's funding it. The "AI safety" framing will be heavy in the air. Most of it will be downstream of monopoly preservation.

The longer arc

Where I think this all heads, in five years:

Open-source models will be 80-90% as capable as frontier models on narrow tasks, at 1% of the inference cost. Specialized industries will run their own fine-tuned models on dedicated hardware. There are companies right now taking AI models and embedding them on hardware chips, and that's a real direction. The frontier labs will sell the very-hardest-task tier as a premium service, but the routine work will not be on their infrastructure.

That's the future where AI-native businesses are durable. The opposite future, where frontier labs own all inference, all data, and all margin, is the one the labs are working toward.

Distillation is the lever. Yours, mine, the open-source community's. Pay attention to this. Fight when it's time to fight.

Wrapping the series

This is the last post of the five-part engineering series the manifesto promised. The arc:

1. The Autonomous Development Manifesto: the printing press analogy and why this matters now.
2. Context Engineering: the discipline that determines whether your agents work.
3. Building a Self-Healing Bug Bot: the architecture of a real autonomous cluster.
4. The Bash Harness: the manager that supervises the brilliant intern.
5. Distillation Is Your Moat: the long game.

If you've read all seven, you understand the technology and the strategy of autonomous coding as well as anyone working in the field today. There is no secret you're missing. The work is in the doing.

If you want a head start (a cluster already tuned, an autonomous engineering team you can describe a SaaS to and watch ship it, a stack you can eject from any time you want) join the Alchemist waitlist. We've spent a year and six figures of compute building this. We're packaging it for you.

Either way: stop being a spectator. The next three years are the formative ones for AI-native software, and the people building right now are the ones who will be telling the story.

Get in the arena.

The answer they expect is a model trick, or a prompt trick, or some clever new agent framework. The real answer is the one nobody wants to hear: we picked one language, one frontend framework, and one cloud, and we refused to support anything else.

Deno. Svelte. Cloudflare.

That's the whole stack. Every customer app we host runs on those three. Every agent we ship is written for those three. We don't take customers whose apps run on something else. We don't make the platform "flexible enough to support React or Vue or Solid." We don't expose a hosting plugin layer. We took the three choices that compose best for an agent-driven world and we welded them in place.

That decision is the single highest-leverage call we've made at Chipp. It's also the call that most of our competitors keep refusing to make, and it's why their autonomy numbers stall out where ours keep climbing.

This post is the argument for why.

The thesis in one line

An autonomous coding platform's effective intelligence is inversely proportional to the size of its decision surface.

Every place where the agent could plausibly pick option A versus option B versus option C is a place the agent will, eventually, pick wrong. Every framework choice, every cloud primitive, every package manager, every test runner, every router convention. Each one multiplies the number of paths the agent has to navigate. The model is good. It's not "infinite combinatorial decision tree" good.

The only known way to make an agent's behavior reliable at scale is to *remove decisions from the surface*. Not by adding rules on top of a sprawling toolchain, but by collapsing the toolchain itself. The autonomous coding platforms that ship working features today are the ones with the smallest possible "what shall I pick" surface. The ones that don't ship are the ones still proudly listing thirty supported frameworks on their landing page.

Constraint is not a tax. Constraint is the feature.

What "one size fits all" actually costs

Let me describe the platform shape I keep seeing pitched, because it sounds reasonable on a slide.

The pitch: a hosted agent platform. The customer brings their existing codebase. Python or Node or Go on the backend. React or Vue or Svelte on the frontend. Deployed to AWS or GCP or Vercel or Fly. The agent reads the customer's repo, figures out the conventions, writes a feature, runs the tests, opens a PR.

It demos well. It always demos well. The first ticket lands. The team congratulates itself. Then the second ticket comes in, on a different customer with a different stack, and the agent's accumulated context from the first customer is *useless*. Then the third ticket lands, with yet another framework combination, and the agent has to relearn everything again. Then the scar-tissue document you'd been building in `CLAUDE.md` doesn't transfer, because half its rules are about library quirks that don't apply to this customer's stack. (Why scar tissue in `CLAUDE.md` is the highest-leverage file in your codebase →)

You spend the next year of company-building writing per-stack adapters. Each adapter is fine on its own. The compound is fatal. Every adapter is a new place to debug, a new set of dependency versions to track, a new permission of failure modes for the agent to discover. The model never gets to compound. The platform never gets to compound. You're maintaining N agents pretending to be one agent, and each of them is mediocre.

The teams running this play out loud right now, you know who you are, will hit a wall where their agents work on toy customer apps and fail on real ones. They will conclude that the model isn't smart enough yet. The model is plenty smart enough. The platform forced the model to do combinatorial work that doesn't need to exist.

The exit from this trap is to *narrow the surface*. Pick the stack. Mean it. Refuse anything else. The customers you lose by being opinionated are smaller than the customers you'll lose by being a worse product.

Why Deno is the right language

Pick one server-side language. Once you've picked it, every reason to pick anything else for that tier collapses. The agent only ever has to know one ecosystem. The skills compound. The scar tissue compounds. The platform compounds.

We picked Deno. Here's why it dominates Node and Python and Go for this specific job.

One binary, one toolchain, one mental model. Deno is a single executable that includes the runtime, the package manager, the formatter, the linter, the test runner, the type checker, and the bundler. There is no `npm` versus `pnpm` versus `yarn` versus `bun` decision. There is no `eslint` versus `biome` versus `oxlint` decision. There is no `prettier` versus `dprint` decision. There is no `jest` versus `vitest` versus `mocha` versus `node:test` decision. The agent runs `deno fmt`. The agent runs `deno lint`. The agent runs `deno test`. There is exactly one right answer to every "how do I X" question. The decision tree the agent has to navigate when working in a Deno repo is *embarrassingly* small compared to a Node repo, and that's the entire point.

TypeScript is the default, not the bolt-on. No `tsconfig.json` archaeology. No "did someone forget to add `@types/node`." No transpile pipeline. You write TypeScript, Deno runs TypeScript. The agent writes TypeScript, the agent runs TypeScript. Type errors surface immediately. The whole class of "the agent generated valid JavaScript that's invalid in this project's TS config" failure mode is gone.

Permissions are first-class. `deno run --allow-net=api.stripe.com --allow-env=STRIPE_KEY ...` is the default shape of a Deno program. The agent's generated code declares what it touches. When the agent goes off the rails and tries to read `/etc/passwd`, the runtime refuses. The model's worst impulses get sandboxed for free. Compare this to Python or Node, where every script has the same authority as the developer running it.

The standard library is real. `@std/http`, `@std/path`, `@std/encoding`, `@std/testing`, `@std/assert`. Things that should not require a package, do not require a package. The set of things the agent might `npm install` to solve a routine task shrinks. Fewer dependencies = fewer choices = less hallucination surface. The agent reaches for `@std/path` because the agent only knows about `@std/path`, because that's what the CLAUDE.md says to use, and that's what's already in the workspace.

URL imports are reproducible. `import { foo } from "jsr:@scope/package@1.2.3"` is the import statement *and* the dependency declaration. There is no separate `package.json` to keep in sync. There is no `node_modules/` to corrupt. There is no lockfile divergence between the agent's working tree and the deploy. The agent that fixes a bug in a function and pushes it is *touching the same artifact* the runtime executes. This sounds boring until you've debugged the third "but it worked on my laptop" failure caused by a transitive dependency drifting in the lockfile.

There's a meta-property here that I think is underrated: Deno is opinionated about the same things autonomous agents are bad at. Toolchain selection. Configuration sprawl. Implicit globals. Hidden permissions. Every place Deno's designers said "we're picking one way" is a place we don't have to write a CLAUDE.md rule explaining which of the seventeen Node-flavored ways our codebase prefers. The framework already enforces the convention. The agent just has to follow the only available path.

"Every language choice an agent can make is a choice the agent will eventually get wrong. The win is removing the choice, not training the agent to choose better." -- Hunter Hodnett, Chipp CTPO

Could we have picked Go? Go has some of the same properties, single binary, single tool, opinionated formatter. We didn't, because the agent has to write *both* server code and shared code with the frontend. Sharing types across a Deno backend and a Svelte frontend is the same TypeScript file. Sharing types across a Go backend and a TypeScript frontend is a code generator and a build step. The friction of crossing the language boundary, multiplied by the number of features the agent ships per day, dwarfs the marginal Go-versus-TS productivity gap. One language, one type system, one mental model.

Could we have picked Bun? Bun is closer to Deno than to Node, and on the runtime axis it's competitive. We didn't, because Bun's posture is "drop-in Node replacement," which means it inherits Node's combinatorial config surface as a feature. Deno's posture is "we picked the answers." We wanted the picks.

Why Svelte is the right frontend framework

Pick one frontend framework. Same logic. Same compounding.

We picked Svelte (Svelte 5, with runes). Here's why it dominates React for an agent-driven codebase.

Less code per feature. This is the boring, load-bearing fact. A typical Svelte component that does what a React component does is somewhere between half and a third the line count. For a human reader, that's a quality-of-life thing. For an agent with a finite context window, it's *capacity*. Every additional line of code the agent has to load into context to reason about the surrounding feature is a line that crowds out something else. Svelte's compiler does the work React's hooks-and-providers ritual makes the developer do explicitly. The shorter source is the source the agent can hold in its head.

The compiler is the framework. React ships a runtime that interprets your component tree at every render. Svelte compiles your component down to direct DOM mutations at build time. The agent doesn't have to reason about render orderings, dependency arrays, stale closures, the rules of hooks, when to memoize, when not to memoize, the seven flavors of effect, server components versus client components, suspense boundaries, or any of the other lore that has accumulated on top of React over a decade. The agent reasons about HTML, CSS, and a small number of runes. That's it.

Runes are a small, consistent surface. `$state`, `$derived`, `$effect`, `$props`, `$bindable`. Five symbols. Each one does exactly one thing. There is no `useState` versus `useReducer` versus `useRef` versus `useImperativeHandle` decision. There is no "is this a controlled component" lore. The agent picks the rune by what it's doing, not by which of the eight historical APIs ended up at the right level of abstraction.

SvelteKit's file system is the routing. `routes/foo/+page.svelte` is the foo page. `routes/foo/+page.server.ts` is the foo page's server load. `routes/foo/+server.ts` is the foo API endpoint. The agent doesn't pick between Pages Router and App Router. It doesn't pick between server components and client components. It doesn't pick between `getServerSideProps` and `getStaticProps` and `loader()`. The filename declares the role. There is one way.

No state management library debate. React projects routinely include three different state libraries (Redux, Zustand, React Query, Jotai, MobX, take your pick) and the agent has to learn which one this codebase uses for what. Svelte projects use runes. State that's per-component lives in `$state`. State that crosses components lives in a `.svelte.ts` file with `$state` at module scope. The store debate that's eaten a decade of React community discourse simply does not exist.

Could we have picked Solid? Solid is closer to Svelte than to React on every axis I care about. We didn't, because Solid is small enough that the customer-facing component ecosystem is thin. Svelte has the second-largest component ecosystem after React, which matters when the agent reaches for "I need a date picker." Solid would have been the right pick if we were optimizing for performance benchmarks. We were optimizing for the agent's daily reach.

Could we have picked React (Next, Remix, plain Vite)? No, for the same reason we didn't pick Bun: React's posture is "everything is a choice, pick wisely." That is exactly the wrong posture for an agent. We don't want our agents picking wisely between four router libraries. We want the agent to not have the choice in the first place.

The component-count tax this saves us is real. A Chipp customer's average feature ticket, when shipped on a React stack, was around 3.2x the diff size of the same feature shipped on Svelte. 3.2x more code is 3.2x more places to put a bug, 3.2x more tokens to load on review, 3.2x more `CLAUDE.md` rules to write about which React patterns we use. Multiplied across the volume of features we ship per customer per week, the framework choice was the second-largest determinant of how much autonomy we could squeeze out of the platform. (The first was the model, and we don't control the model.)

Why Cloudflare is the right cloud

Pick one cloud. Same logic. Same compounding.

We picked Cloudflare. Workers for compute, R2 for blobs, KV for caches, D1 for relational data, Durable Objects for stateful coordination, Queues for async work, Pages for static assets, Custom Hostnames for per-customer domains, Zero Trust for auth gating. One platform, one CLI (`wrangler`), one mental model.

Here's why it dominates AWS and GCP for an agent-driven backend.

One control plane, one API. When an agent needs to provision a queue, it calls one wrangler command and an HTTP endpoint. It doesn't have to pick between SQS, SNS, EventBridge, Kinesis, MSK, and AppFlow. It doesn't have to know which of those has the right semantic for this customer's job shape. The agent has Queues. The customer has Queues. The decision tree has one branch.

The primitives are general-purpose. Workers + R2 + D1 covers the shape of every customer app we've shipped. The agent learns those three. The agent ships features. The agent doesn't go on a multi-day expedition learning that the customer's logging system happens to require IAM role A to assume IAM role B to publish to topic C subscribed by Lambda D writing to S3 bucket E. That sentence is a parody of cloud onboarding, except it's also literally what we paid the AWS tax for in a previous life.

Edge-first is deterministic for the agent. Workers run at the edge, the same way everywhere. There is no `us-east-1` versus `us-west-2` decision. There is no "did we forget to deploy this to all regions" failure mode. When the agent deploys, the deploy is global. When the agent verifies, the agent's verification reflects what the customer's customer will see, anywhere on earth. The "works in dev, fails in prod" gap, which is mostly a region/availability/IAM gap in AWS shaped systems, doesn't exist.

Wrangler is the agent's hands. Every Cloudflare resource is reachable from `wrangler`, and `wrangler` runs in a shell, and the agent has a shell. We don't need a custom orchestration layer to give the agent provisioning capability. The agent writes `wrangler.toml`, the agent runs `wrangler deploy`, the agent reads the output. The same tool a human operator would use is the tool the agent uses, which means the agent's mistakes are debuggable by the same workflow that debugs a human's mistakes. (Why the bash harness is the right abstraction →)

Workers are fast to deploy and isolated by default. A `wrangler deploy` is typically completed by the time the agent's next tool call fires. That tight loop is what makes autonomous verification practical. The agent ships, the agent curls the deployed endpoint, the agent observes the response, the agent decides. If the deploy round-trip took the length of a coffee break, autonomous verification would simply not be a workable shape. Cloudflare's deploy primitives are *agent-paced*, which is a phrase I never thought I'd need to coin but which now describes the most important property a cloud can have for this kind of work.

Per-customer isolation comes for free. Each customer's deploy is a separate Worker. Each customer's data is a separate D1. Each customer's blobs are a separate R2 prefix. Cross-tenant leakage is a tenancy-shape problem, not an IAM-policy problem. We don't write tenant-isolation middleware. We don't write tenant-isolation tests. The platform's primitive is the boundary.

Could we have picked Fly? Fly is close to Cloudflare in posture (opinionated, edge-first, small surface). We didn't, because Fly is positioned as "run your container anywhere," which puts the container-image debate back on the table. We didn't want our agent making Dockerfile decisions. Cloudflare Workers don't have a container concept at all. The agent writes TypeScript, the agent deploys TypeScript, the platform handles the rest. The whole containerization layer is a decision surface we eliminated.

Could we have picked Vercel? Vercel is great at the React-flavored slice of the world, but its primitives outside that slice (blob storage, queues, durable state) are thinner and lean on third-party adapters. We didn't want our agent gluing together Vercel-plus-Upstash-plus-Neon-plus-Inngest, each with its own API and its own dashboard. Cloudflare's one-platform claim is the closest a cloud has come to "one mental model for everything the agent needs."

Could we have picked AWS or GCP? No. The hyperscalers are *the canonical bad shape* for autonomous coding. Three thousand services, fifteen ways to do every job, IAM policies that take human engineers years to internalize. We are not going to outwit AWS's combinatorial sprawl by being clever about prompts. We are going to avoid it by not standing on it.

What you give up

I want to be honest about what this decision costs, because the "constraint is the feature" pitch glosses over real tradeoffs.

You lose customers who already have a stack. A customer running a Rails monolith on Heroku is not our customer. We can't agent-ize their app. We don't try. The customers we sign are the customers who haven't committed to a stack yet, or who explicitly want to greenfield on ours because the autonomy multiplier is worth the migration.

You lose engineers who want to pick. Some engineers want a platform that respects their craft, which often means respecting their existing toolchain choices. Our pitch is the opposite. The platform makes the choices. The engineer's craft is in the domain, not the stack. Some prospective hires bounce off this. The ones who stay are the ones who internalized that the stack stopped being a competitive advantage years ago.

You take on the bet that the chosen tools stay good. If Deno collapses, we have a migration. If Cloudflare massively raises prices, we have a migration. If Svelte 6 makes runes obsolete in a way we can't follow, we have a migration. The constraint binds us as much as it binds the customer. We accept that bet because the alternative, supporting twelve stacks badly forever, is strictly worse and we can see the future where that company looks like a museum.

You can't be everything to everyone. Good. The platforms that are everything to everyone are the ones whose autonomous-coding numbers stop at "demo working" and never reach "running production for two months unattended." We'd rather be one thing to a smaller everyone, work well, and let the autonomy compound.

What this looks like in practice

A customer-template repo with a `CLAUDE.md` that knows it's a Deno + Svelte + Cloudflare project. The scar-tissue rules are about Svelte 5 runes, Deno 2 APIs, wrangler conventions. There is no rule that says "if this is a React project, do X; if this is a Vue project, do Y." The agent never has to branch on stack identity. The rules apply directly.

A reproducible E2B sandbox with Deno installed, wrangler installed, Svelte's tooling installed, Chrome installed for browser-driven verification. Every agent run starts from the same base image. The agent never spends a tool call figuring out whether `pnpm` or `npm` is the right installer here, because the answer is always `deno` and the answer is in the base image. (How we built that sandbox →)

A deploy pipeline that's two commands: `wrangler deploy` and curl the result. The whole "did the deploy land" round-trip is short enough that the agent doesn't need a separate state machine to model it. The agent ships, the agent verifies, the agent moves on. The model's working memory is enough; we never had to build a "track in-flight deployments" subsystem because the deployment never has time to be in flight.

A per-customer Worker that isolates everything. When the agent screws up, the blast radius is one Worker. When the agent ships a fix, the rollout is global and atomic. There is no rolling-deploy interlude where some customers are on the old code and some on the new. The agent doesn't have to reason about partial-rollout failure modes because partial-rollout doesn't exist.

A frontend that ships fewer lines of code per feature, which means the review pass loads less context, which means the agent's `CLAUDE.md` review rules apply to a smaller surface, which means the same fixed budget of review attention catches more bugs.

These properties are not independent. They compose. Each constraint we accepted lets the others compose harder. The reason our autonomy numbers look the way they do is that the platform itself was designed to make autonomy the default path, and the platform's design is the stack choice.

The general principle

If you're building an autonomous coding platform, the most important spec is *not* your agent harness. It's not your model picker. It's not your prompt library. It's *the platform your agent ships code for*.

The agent is the smallest part of the system. The platform is the part you can shape. Shape it the way the agent's failures want you to.

Specifically:

• Pick one language. The language with the best built-in tooling, the smallest config surface, and the strongest cross-tier story with your frontend.
• Pick one frontend framework. The framework with the smallest source-code footprint per feature, the most opinionated conventions, and the smallest "lore surface" the agent has to learn.
• Pick one cloud. The cloud with the smallest set of general-purpose primitives, the tightest deploy round-trip, and the most isolated per-tenant shape.

Then refuse to compromise on any of those three. Refuse politely. Refuse with a smile. Refuse the customer who insists on Python. Refuse the engineer who insists on Next. Refuse the investor who tells you you'd be "more flexible if you supported AWS." Flexibility is what the platforms that don't ship have. We picked the platforms that ship.

When someone tells you the model isn't smart enough to be autonomous on their stack yet, take a look at their stack. Most of the time, the model is plenty smart. The stack is the bottleneck. The decision surface is too wide. The combinatorial cost of every "which library" question is eating the model's working memory. Shrink the surface and the same model gets dramatically more autonomous overnight.

This is the lesson I wish more of the autonomous-coding ecosystem would internalize. We are not in the era of "the model will figure it out." We are in the era of "the platform will let the model figure it out, or it won't." The platforms that pick will win. The platforms that don't will spend the next year of company-building writing per-stack adapters and wondering why their demos plateau.

Deno. Svelte. Cloudflare. Three picks. One stack. Autonomy compounds.

That's the post. The follow-up is the platform itself, which is what we ship on every weekday at Chipp, and what the autonomous development manifesto lays out in full.

If you're building toward the same shape, I'd love to compare notes. If you're building toward the everything-to-everyone shape, I'd love to come back in a year and compare numbers.

Missed our live session? No worries. Recording is here.

Scott walked through everything you need to know about using AI for customer support, from the tech behind it to real examples of businesses already running it. Here's a breakdown of everything covered.

Why AI Customer Support is Different Now

This is not the answering machine of the past. The old answering machine was really just a message-taking machine. It never gave answers back. Now, AI can actually answer questions and take a message. That's a big deal.

A few things that change with AI-powered support:

• Always on, 24/7, no hold time
• Everything is logged and searchable
• Multilingual out of the box, no extra setup needed
• Scales on usage, not headcount

One data point from Chipp's own experience: when users are given the option to talk to a human or keep going with AI, about 60% stick with the AI to get their answer.

Two Ways Voice AI Works

Understanding how voice is built helps you pick the right setup for your use case.

Real-Time Voice

This is the highest-quality option. Two WebSockets stay open throughout the call, so speech goes in and comes back out without being converted to text in between. The result is super low latency, natural conversation, and better interruption handling. Great for tutoring or high-touch customer support where you want it to feel as close to human as possible. It is also the most expensive option.

Speech-to-Text and Text-to-Speech (Pipeline)

The most popular approach. Your voice gets transcribed to text, the AI processes it, and then turns the response back into speech. More steps, slightly more latency, but way more flexibility. You can mix and match providers and swap out components as things improve.

Bottom line: real-time feels the most human. Pipeline gives you the most control.

Building One Agent, Deploying Everywhere

A common mistake is building a separate agent for every channel. Instead, build one brain and deploy it across platforms, each with slightly tweaked instructions. This keeps things manageable and consistent.

Channels you can deploy to:

• Web chat — the chat bubble on your site
• SMS and WhatsApp — same brain, different interface, keeps conversation history
• Phone — a dedicated number your AI picks up

For phone, most businesses start simple. Forward your existing business number to your AI number after hours, say 5 PM to 8 AM. When the team is back, shut off the forwarding. You get AI coverage without replacing your human team.

What You Can Teach Your Agent

Your agent's knowledge and behavior are fully customizable. You can give it:

• Business knowledge — hours, services, product catalog, FAQs
• Tone — short and polite for phone, warmer for chat
• Escalation rules — when does the call go to a human and which department?
• Tool access — connect it to your CRM, booking software, Calendly, and more

Tools are what make agents actually useful in real time. AI already knows what teeth whitening is, but it does not know if your 2 PM slot is open. That is what tools are for.

Real Example: Catalyst Medical Center and Clinical Spa

Catalyst has two sides to their business. The spa side covers facials and massages. The medical side covers dermatology and ENT. Two booking systems, different rules for each.

Here is how they are running it:

• Real-time voice stack for the best call quality
• AI takes over at 5 PM and humans handle the day
• Booking integrated with Zenoti for spa appointments and eClinicalWorks for medical
• Medical appointments are human-only since certain procedures need pre-screening

Before AI, Mondays started with an hour of voicemail catch-up. Now the team comes in with a prioritized, searchable log of everything that came in over the weekend. Fewer follow-ups, faster response.

How to Keep Your Agent Getting Better

Deploying is just the start. The real value comes from the improvement loop:

1. Log — every conversation is recorded and searchable
2. Review — spot questions the agent did not answer well
3. Improve — paste those questions into The Alchemist and let it update the agent
4. Redeploy — push the updated agent live

Catalyst does this every two weeks. You can see exactly what people are asking and tune accordingly.

Voice Customization: More Than You Think

• Choose from dozens of voices across providers
• Clone a voice by recording about a minute of audio and the agent takes on that tone
• Accent matters, especially for multilingual use cases. Consider cloning someone who speaks the dialect your customers use
• Set interruption sensitivity higher for quiet phone calls and lower for noisy in-store environments
• Multilingual by default. The agent detects the caller's language and responds in kind, no extra training needed

Call Routing and Transferring

No more pressing 1 for English or 2 for support. AI handles triage intelligently.

Two ways to do it:

• Keyword-based — say "emergency" or "human" and it forwards to the right number
• AI-based — the agent reads the conversation and decides where to route based on topic or tone

You can also set up outbound campaigns now for appointment reminders, follow-ups, and cold outreach. Upload a CSV, set calls per minute, and let it run.

Building Your First Agent

Want to try it? Start here:

1. Go to chipp.ai and sign up, it is free
2. Click Templates and search for Phone Receptionist
3. The Alchemist will walk you through personalizing it, just answer a few questions
4. You will have a working agent in about 60 seconds

For voice cloning and phone numbers you will need a Studio or Studio Pro plan. Phone numbers are about $1 per month and usage is charged per actual second, nothing is rounded up.

What is Coming Up

• 📅 **Autonomous Marketing (May 20)** — drop in a transcript or blog post and get content across every channel automatically.
• 💻 **Autonomous Dev (May 27)** — for the technical folks, see how Chipp's dev cluster is built and try it yourself
• 🎓 **Business Agents of Change** — a hands-on 6-session cohort starting May 12. Build a full support stack, sales stack, ops stack, and analytics stack.

Questions? Reach Scott at scott@chipp.ai

The pitch was honest. The category name was ambitious. Pair programming, as practiced by humans, is two people taking turns at one keyboard. One drives, one navigates, both think. Copilot was *not* that. It was a smarter autocomplete with a better marketing department.

The honest pitch, *autocomplete that actually understands your codebase*, would have been more accurate but less aspirational. Marketing won. The "AI pair programmer" framing stuck. And four years later, the framing is the thing holding most builders back from seeing what AI in engineering can actually do.

This post is about the upgrade path. Three roles for AI in your engineering org, pair programmer, coworker, autonomous engineer, what each one actually means, and the org-chart implications when you move between them.

Role 1: AI as pair programmer

This is where Copilot started, where Cursor lives, where Cody and Tabnine and Continue all sit.

The model finishes your line. The model writes a function when you describe one in a comment. The model fixes a syntax error you didn't notice. The model is *latency-bound*, it has to be fast enough to keep up with your typing, which means it has to be small enough to run in real time, which means it can't reason very deeply about what you're doing.

The output of an AI-pair-programmer setup looks like a slightly faster human engineer. You ship 10-30% more code per hour than you would have without it. The shape of your day is unchanged. You're still typing all day. You're still reviewing every line. You're still the one who decides what file to open next and what to do once you're there.

This is a real productivity gain. It's not a category change.

What you give up to operate at this level: nothing. Adoption is friction-free. Every engineer on your team can be using a pair programmer by tomorrow afternoon and there are no architectural changes required.

What you fail to gain by stopping here: everything below.

Role 2: AI as coworker

The coworker shows up around 2024 with the agent capabilities baked into Claude Code, Cursor's agent mode, the Codex CLI, and a few others.

The shape of the work changes. Instead of the model finishing your line, the model takes a goal and *runs a session* against the goal. You say "investigate why our billing endpoint is returning 500s" and the model spends ten minutes reading files, querying logs, forming a hypothesis, writing a fix, running tests, telling you what it did.

You're still in the loop. You watch. You course-correct. You decide when the session is done. But you're not at the keyboard the whole time anymore. The model is operating in *minutes-long blocks* of focus, and you're operating in the spaces between.

The output looks like having a junior engineer at the desk next to you. You hand them tickets. They take a stab. You review. The throughput per ticket goes way up, junior engineers are bottlenecked by their own typing speed; the agent isn't. The throughput of *your* time goes up because you're not typing during the agent's blocks; you're handling other things.

What you give up to operate at this level: trust. You have to let the agent run for ten minutes without watching every keystroke. The first time it makes a wrong-turn decision and burns ten minutes of context, you'll want to go back to the pair-programmer model. The teams that hold the trust line through the first month make it past this. The teams that don't end up reverting.

What you fail to gain by stopping here: scale. The coworker is still bounded by your attention. You can run *one* coworker session at a time because you have to be available to course-correct it. You can't sleep through the night because you have to be available to review what the coworker shipped during the day.

This is where most ambitious teams sit in mid-2026. It's a good place. It's also not the destination.

Role 3: AI as autonomous engineer

The autonomous engineer is the role most builders haven't seen yet, because it requires a different *organizational* setup, not just a different tool.

The model takes a goal. It runs a session. It verifies its own work, opens a browser, takes a screenshot, reads logs, fixes the things it broke. It commits. It pushes. It deploys. There is no human at any step.

Multiple autonomous engineers run in parallel. We have eight workers running on a single workstation at Chipp. Each one is its own Claude Code instance, in its own git worktree, with its own dev server on its own port, fielding tickets from a shared queue.

The output isn't *more code per hour*. The output is *more shipped product per dollar of payroll*. We ship 20-30 production changes a day on a two-person engineering team. The PR queue is empty because there are no PRs. The on-call rotation is empty because the cluster handles its own incidents.

What you give up to operate at this level: your PR review process, your habit of reading every diff, the comfort of knowing exactly what's in production. (The full list of trade-offs →)

What you fail to gain by stopping at the coworker level: the ability to run while you sleep. The ability to compete on engineering capacity with teams an order of magnitude larger than yours. The ability to ship features that wouldn't have survived a normal cost-benefit analysis.

"The AI wasn't an assistant. It was the engineer. I was the manager." -- Hunter Hodnett, Chipp CTPO

The org chart at each level

Here's where it stops being about tools and starts being about people.

Pair-programmer org chart

The org looks like a normal engineering team. Engineers report to engineering managers. Engineers write code. EMs run people. There are PRs. There are reviews. There are sprint planning meetings.

The shape doesn't change because the work doesn't change. The engineers are 10-30% faster but they're still doing what they were doing.

Coworker org chart

The shape starts to shift. Engineers spend less time typing and more time *steering*, defining tickets, reviewing the agent's work, fixing the parts the agent got wrong. The senior engineer's day starts looking more like a manager's day.

EMs notice that some of their direct reports are shipping at suspicious volumes. The "10x engineer" trope, previously folklore, starts to look real.

This is also where the awkward middle starts. Junior engineers struggle, because the agent is good at the work juniors used to learn from. The "draw the rest of the owl" jokes hit different when the agent draws most of the owl and the junior is supposed to learn by drawing it themselves.

Autonomous-engineer org chart

The shape is *fundamentally* different. There are no engineers writing code in the way the prior org charts had. There are *engineering managers*, humans who manage clusters of agents. There are *architects*, humans who decompose product intent into ticket-shaped work and review the agent's outcomes. There are *infra people*, humans who maintain the cluster, the harness, the MCP fleet.

Headcount drops. The remaining roles get *more* important, not less. A two-person autonomous engineering team can deliver what a fifteen-person traditional team could. Each of those two people is doing higher-judgment work than any of the fifteen.

This is the org chart most companies in 2030 will have. Most companies in 2026 do not. The transition is the hard part.

Upgrading your own role

If you're a working engineer reading this, the question is what to do about your own job.

I'll give you the honest answer. Your job in the coworker world is what your job in the autonomous-engineer world is going to be: less typing, more decomposition; less review, more architecture; less owning code, more owning the system that produces code.

Three things to start doing now:

1. Stop measuring yourself by lines of code

Lines per day was a noisy metric before AI; it's worse than noisy now. The agent can produce more lines than you in any given hour. If your self-image is wrapped up in being a productive typist, the next two years are going to feel bad. Decouple now.

The new metric is *tickets shipped per dollar of token spend*. Or *features merged per week of clock time*. Or *production stability holding while shipping volume goes up*. Find a metric that values judgment over typing.

2. Get good at decomposing

The hardest part of running an autonomous cluster is turning vague intent into pipeline-sized tickets. *"Build a billing dashboard"* is not a ticket. *"Add a usage breakdown chart to the existing billing settings page, sourced from the same data the credit balance uses, with the design pattern from the org members table"* is a ticket.

Decomposition is a skill. It's the skill of being a good tech lead, but more granular. Start practicing it now even on work you're doing yourself. You'll be doing nothing else in two years.

3. Get good at reading agent output fast

In the autonomous-engineer world, you'll be reviewing more of the agent's work than your own, hundreds of small commits per week, mostly auto-verified, but with a few that need human eyes for judgment calls.

The skill of speed-reading a diff and forming an opinion in 60 seconds is undervalued today. It will be the most valuable engineering skill of 2028.

Start practicing on the agent's output now. Set a timer. Make snap calls. Build the muscle.

What this means for hiring

If you run engineering hiring, the implication is that the profile you want is shifting fast.

The pair-programmer-era hire was a strong typist with good fundamentals, someone who could turn a Jira ticket into shipped code reliably.

The autonomous-engineer-era hire is a strong *judge* with good fundamentals, someone who can look at an agent's output and tell you whether it's right, wrong, or interesting; someone who can decompose a vague product brief into pipeline-sized tickets; someone who's comfortable trusting a cluster to push to production while they sleep.

The fundamentals haven't changed. Algorithms, data structures, system design, debugging instincts, those still matter, because you can't judge an agent's output if you don't understand the underlying engineering. What's changed is the layer the human operates at. You're not the engineer anymore. You're the engineering manager, for a team of agents that doesn't go home at night.

Hire for that. Pay for that. Promote for that. The teams that figure out the new hiring profile first will end up with the engineers everyone else wants in 2028.

Which kind of engineer do you want to be in 2027?

There are three honest options.

Option 1: Pair-programmer engineer. Same job you have today, slightly accelerated. Plenty of teams will still operate this way in 2027. They'll be losing market share. You'll be paid like a 2024 engineer with a faster IDE. Defensible if you're senior enough to ride out the contraction.

Option 2: Coworker-era engineer. You've absorbed the agent into your daily flow. You're 5-10x more productive than your 2023 self. You're still in the inner loop on every change. This is the median ambitious engineer in 2026. It's a defensible position for two more years, then it gets hard.

Option 3: Autonomous-engineer-era engineer. You manage agents. You decompose work. You design systems. You judge outcomes. You're the EM of a cluster that ships more product than your old fifteen-person team did. This is the role that compounds.

I know which one I'm betting on. We're building Alchemist for the people making the same bet.

[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)

If you want the long-form case for the destination, read The Autonomous Development Manifesto.

If you want the architectural difference between Stage 3 and Stage 5, read Vibe Coding vs Autonomous Development.

If you want to see what an autonomous cluster looks like under the hood, read Building a Self-Healing Bug Bot.

I gave him a long answer. He cut me off. *"Just tell me which one I should be doing."*

The short version: vibe coding is the second-best place to be in 2026. Autonomous development is the best. They are not the same thing, and the gap between them is the most consequential architectural decision a builder will make this year.

This post is the long version of that answer. It walks the five-stage maturity curve from autocomplete through autonomous, defines each rung honestly, and lays out a 90-day plan for climbing from vibe coding to autonomous development without the moves that usually go wrong.

The maturity curve

There are five stages of human-AI coding collaboration. Each one absorbs the prior one. Stage 5 contains every move from Stages 1 through 4, but the unit of work changes at every step.

Stage 1. Acceleration. A model finishes your line. You're still the author. Output velocity: 1.1x. Your fundamental job hasn't changed.

Stage 2. Augmentation. A model writes a function. You read it, edit it, commit it. The senior engineer still does most of the thinking. Output velocity: 2x. Copilot's original pitch.

Stage 3. Vibe coding. A model writes most of the code. You become an editor in the loop, accepting or rejecting diffs in conversation with the agent. Output velocity: 5-10x for a session. Demos are great. Production code is hit or miss. This is where most of the industry sits today.

Stage 4. Agentic coding. The agent runs tools, files, shell, browser, database, to accomplish a goal you stated. With the right setup, the agent can verify its own work. The human is still launching and supervising each session. Output velocity: 20-50x for a session. Each session needs a person to start and watch.

Stage 5. Autonomous development. Multiple agents run unattended in parallel. Goal-directed. Self-verifying. The human role is decomposition (turning intent into tickets) and judgment (reviewing outcomes). Output velocity is no longer a useful metric, *organizational capacity* is.

The story most builders tell themselves is that Stages 3 and 5 are the same thing with more polish. They're not. Stage 5 contains an architectural commitment Stage 3 doesn't have, and getting from one to the other is most of the work.

What "vibe coding" actually means

Andrej Karpathy coined the term in February 2025: *"give in to the vibes, embrace exponentials, and forget that the code even exists."* The agent does the work; the human steers from the back seat.

In practice, vibe coding means three things:

1. The human is in the loop on every change. You see a diff. You accept or reject it. You re-prompt when something's wrong.
2. The agent doesn't verify its own work. Verification is the human's job, you click around, check the output, look for bugs.
3. The session runs in real time, with the human watching. There's no batch mode. There's no overnight queue.

Vibe coding is *fast*. A single session can ship a feature that would have taken a week of by-hand engineering. It's also *flow-based*. The output of a vibe-coding session depends on the human's attention, taste, and ability to course-correct in real time.

The thing it isn't is *scalable*. The bottleneck on a vibe-coding setup is the human. You can't run twelve vibe-coding sessions in parallel because you can't watch twelve diffs at once. Your output velocity is bounded by your ability to review.

This is the ceiling Stage 3 hits. Most of the industry has hit it. The teams who think they're at the frontier of AI coding because they ship every day in Cursor or Claude Code interactively, they're at Stage 3. They're operating well. They are also one architectural step away from a different category of business.

What autonomous development means (the same definition, with the contrast sharpened)

Autonomous development is what happens when you remove the human from the inner loop.

The agent gets a goal. It executes against the goal. It verifies the result. It pushes the verified result to production. There is no human in any of those steps. The human's role is upstream of the work (decomposing goals into tickets) and downstream of it (judging outcomes), not inside the work itself.

This is not vibe coding with extra polish. It's a different architecture.

In autonomous development:

1. The session runs without a human watching. You launch it and walk away. It might run for thirty minutes. It might run overnight.
2. The agent verifies its own work. Browser MCP for UI. Test suite for code. Logs for runtime behavior. The agent doesn't trust itself; the agent *checks* itself.
3. Multiple sessions run in parallel because no human is in the loop on any individual session. Eight workers, each on its own port, each in its own git worktree, each shipping independently.

The architectural commitment that separates Stage 5 from Stage 3 is the verification loop. Without it, you can't autonomy. With it, you don't need a human in the loop. Everything else in autonomous development, the bash harness, the multi-stage pipeline, the doc auto-load, the sub-agent dilution, exists to support the verification loop or to clean up after it.

"Vibe coding ends with the diff. Autonomous development ends with verified production code." -- Hunter Hodnett, Chipp CTPO

Why most teams stop at Stage 3

Two reasons. Both are honest.

Reason 1: Stage 3 is genuinely good. Vibe coding ships features faster than the manual baseline. Builders feel productive. Customers get more software. Investors see velocity. The pain that would push a team to climb to Stage 5 doesn't exist as long as the team is happy with Stage 3 throughput.

Reason 2: Stage 5 is genuinely scary. It requires deleting your PR review process, trusting the cluster to push to production, and rebuilding your incident response around an autonomous self-healing pipeline. The first two weeks of running autonomously are *deeply* uncomfortable for engineers used to controlling every commit.

The teams that stay at Stage 3 forever are the ones who decide the comfort is worth more than the velocity. That's a defensible position right up until a competitor crosses to Stage 5.

When that competitor exists, Stage 3 becomes untenable. They're shipping at output velocities the human-in-the-loop architecture can't match. Their bug-fix latency is measured in minutes, not days. Their on-call rotation is empty. Their engineers spend their time on architecture and judgment instead of typing and reviewing.

You can stay at Stage 3 against a Stage 3 competitor forever. You can stay at Stage 3 against a Stage 5 competitor for about a year.

How to climb from Stage 3 to Stage 5 in 90 days

Most teams who try to climb fail because they try to climb in one move. They don't. The climb is six discrete steps, and skipping any of them produces a half-implementation that's worse than where you started.

I'll lay them out in the order they should happen.

Days 1-14: Build a verification loop

This is the most important step and the one that gets skipped most often.

Pick one of your features. Build a browser MCP that knows how to spin up your dev server, navigate to the relevant page, take a screenshot, and read the console logs. This doesn't have to be your *production* dev server, a local Chromium instance and a small custom MCP wrapping it is enough.

Then prove the loop end-to-end. Have the agent make a deliberately broken change. Run it through the verification loop. Watch it catch the break and fix it. If the loop works on a single deliberately-broken case, it'll work on the harder cases.

If the loop doesn't catch the break, you don't have a verification loop. Iterate until it does.

Days 15-30: Move from one context window to a multi-stage pipeline

Take the workflow you've been doing in one Claude Code session, investigate, write code, review, push, and split it into stages. Each stage is its own session. Each session reads only the markdown file the prior stage wrote.

Two stages is enough to start: a *plan* stage that outputs a `plan.md` describing what to do, and an *execute* stage that reads `plan.md` and does it. Add review and docs stages later.

The discipline you're building here is *fresh-context handoff*. Once it's habitual, your sessions stop running out of context budget, your hallucinations drop, and your token spend per ticket goes *down* even though you're using more sessions. (Why this works →)

Days 31-45: Build the bash harness

You can't run a session unattended without a manager. The bash harness is the manager. It enforces timeouts, kills sessions that hang, bans dangerous commands, forces commits, cleans up worktrees.

Start with the skeleton in the bug bot post. Tune the timeouts to your workload. Add bans for any dangerous flag you've ever seen Claude attempt.

The harness is the thing that lets you walk away from the session. Without it, autonomous development is a research demo. With it, it's a production system.

Days 46-60: Wire up production triggers

Until now, you've been launching sessions manually. To get to Stage 5, sessions need to launch *themselves*, from production errors, customer reports, performance alerts.

Pick one trigger. We started with a Grafana webhook firing on production errors. Slack tag is the second-easiest. Email forward is the third. Anything that turns a real-world signal into a ticket in your queue is a trigger.

Once tickets land in your queue without you typing them, the cluster starts to feel autonomous. Because it is.

Days 61-75: Delete your PR queue

This is the step that separates the teams who actually reach Stage 5 from the teams who half-implement.

When the cluster pushes a fix it has verified itself, the PR is the wrong layer. The verification has already happened. The PR is just a delay.

Delete the PR. Push to staging. Let the deploy go. The cluster will catch its own breaks via the same trigger system that catches everyone else's.

This will feel wrong. Senior engineers will object. The objections are the right shape, *what if the cluster ships something bad?*, and the answer is *the cluster will fix what it ships, faster than any review queue would have caught it.* You have to either trust the loop or stay at Stage 3.

Days 76-90: Add the documentation auto-build

The last discipline. Every successful autonomous run should write or update markdown documentation in your `/docs/` folder. Future runs read those docs as context. The system gets smarter over time.

This is the part that compounds. After a quarter, your `/docs/` folder is the textbook of your codebase. After a year, it's a moat, your cluster works better on your codebase than any general-purpose autonomous system could, because it has the documentation no one else has.

By day 90, you're at Stage 5. Not perfectly. Not for every kind of work. But the architecture is in place, and from here it's incremental tuning.

What you give up

Honesty matters. Climbing to Stage 5 costs you things.

You give up the ability to read every diff. This is the hardest one for engineers attached to craft. You will, sometimes, see code in production you didn't write. Most of the time it'll be fine. Some of the time it'll be ugly. The pattern catches up over time as your `CLAUDE.md` accumulates style rules, but the first month is rough.

You give up the dopamine of fixing bugs yourself. Bug fixing is satisfying. The autonomous cluster steals that satisfaction. You'll have to find your dopamine in architecture, judgment, and the kinds of work the cluster can't do.

You give up some headcount leverage. You'll have a harder time hiring engineers who want to write code all day, because the cluster is doing most of that. You'll attract a different profile, engineers who want to design systems and lead agents.

You give up the comfort of the PR queue as a control mechanism. The verification loop replaces it. You will, intermittently, miss the PR queue. The first time the cluster ships a bug, you will think *I should have caught that*. Then you'll watch the cluster fix the bug it shipped, and you'll get over it.

What you get back

You get back your nights and weekends. This is not a metaphor. The cluster runs while you sleep. Production fires fix themselves. The on-call rotation goes empty.

You get back your engineering capacity for hard problems. When the routine work is happening autonomously, you spend your day on the architectural decisions only a human can make. The work gets *more* interesting, not less.

You get back the ability to ship features that don't survive a cost-benefit analysis at a normal engineering org. Redundancies. Polish. Anti-fragile fallbacks. Things that wouldn't justify a sprint become weekend tickets for an idle worker.

You get back the ability to compete with teams an order of magnitude larger. This is the one that matters most strategically. Your two-person team becomes the productive equivalent of a fifteen-person team. Your fifteen-person team becomes the equivalent of a hundred. Your competitive position changes shape.

The simple version

If you're still vibe coding in 2026, you're operating well. You're shipping faster than the team next door who is still in Stage 2 review-everything mode.

If you're vibe coding in 2027, you'll be losing market share to competitors who climbed to Stage 5 in 2026.

The window in which Stage 3 is competitive is finite, and it's closing faster than most builders realize. Climb the curve while it's still cheap to climb.

[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)

If you want the high-level case for the destination, read The Autonomous Development Manifesto.

If you want the implementation playbook for Stage 5, read Building a Self-Healing Bug Bot.

If you want the discipline that makes any of this work, start with Context Engineering.

Software is in 1450 right now.

For the last fifty years, producing software and distributing it have been welded together. To ship a feature, you needed someone, usually a credentialed someone, to hand-write the lines. To run a software business, you needed a roster of those someones. Every SaaS price tag is, ultimately, a way of paying down the cost of the team that wrote the code.

Autonomous coding agents are pulling those two halves apart. The act of producing software is delaminating from the act of running a software business. That's the thesis, and it's the thesis Alchemist is built on.

I'm going to make the case for what's actually happening, what isn't, and why we're betting our company on it.

What changed

I've been a software engineer at Reddit, at Amazon Music, at Home Depot. I've been an engineering manager. I've shipped a lot of code by hand. None of that prepared me for the last six months at Chipp.

We don't write code anymore. Scott, my co-founder, and I have eight Claude Code sessions running in parallel on my laptop right now, and they're shipping features straight to production. Not pull requests. Not "AI-assisted commits." Production. There is no human review gate between the agent and the live system. We deploy 20 to 30 times a day. Two months ago I started sleeping through the night for the first time since we raised our seed round, because the agents, not me, get paged when production breaks, and they fix it before I wake up.

This isn't a hype reel. It's a normal Tuesday. The autonomous cluster has been running in production for two months. It's how we built our agentic commerce protocol implementation. It's how we built our voice-agent stack. It's how our customer support works: when a customer Slacks us a bug, an AI agent reads our codebase, writes the fix, verifies it in a real browser, pushes it to production, and posts the result back in the channel. Median time from "this is broken" to "this is fixed in prod" is around thirty minutes, and we're trying to get it to ten.

I tell people this and they nod politely and assume I'm exaggerating. I'm not. The reason I'm not is the reason this manifesto exists.

Why now and not last year

Three things compounded.

First, the models got good enough. Claude Opus 4.6 was the inflection point for us. Below that line, the agent would write code that looked plausible but didn't run; it would hallucinate function signatures; it would take twelve turns to do what should have taken two. Above that line, you can hand it a bug report and walk away. Opus 4.6 is the printing press of this analogy: without it, none of the rest matters.

Second, the *tool surface* got rich enough. Two years ago, an LLM was a chat interface. Now it's a programmable agent that can read files, run shell commands, query a database, drive a browser, hit your production logs, and call any HTTP API on the internet. The Model Context Protocol (Anthropic's USB-for-AI standard) is the boring detail that makes this whole thing work. The model still hallucinates plenty. But now it can *check itself*. It can take a screenshot of the page it just built and notice that the button is the wrong color. It can read its own server logs after the deploy and notice that the error rate spiked. The hallucinations stop costing you when the agent has hands and eyes to verify with.

Third, *context engineering* turned out to be a real skill. The first time I tried to get an agent to ship a feature autonomously, it failed. Not because the model was dumb. Because I dumped a 200,000-token codebase into its context and asked it to fix something on line 14,000. We had to figure out (and we did, painfully, over thousands of dollars in token spend) how to load only the relevant context into a finite window, how to summarize without losing the load-bearing details, how to chain agent runs together so the output of one becomes the input of the next without information loss. That's not a model improvement. That's a software engineering discipline. Anyone can learn it. Most people haven't yet.

When those three things land together (capable model, rich tool surface, learned discipline) you get autonomous software development. Which is what Alchemist is.

What this changes

The unit economics of software flip.

Before: a feature costs you one engineer-week. Maybe two. The engineer gets paid whether the feature is valuable or not. To run a software business, you stockpile engineer-weeks. That's why software companies look like software companies: most of the budget is people, most of the people are engineers, most of the engineers are working on things you can't sell yet.

After: a feature costs you a few dollars in API tokens and the time it takes you to *describe* it. Most of our changes at Chipp cost between \$2 and \$4 in token spend, end to end: research, implementation, code review, deploy. A senior engineer's hourly rate, by comparison, is somewhere north of \$150 an hour fully loaded. The arithmetic is grim if you're a ten-thousand-person engineering org and exhilarating if you're two people trying to ship a venture-backed product.

This is the part that most public commentary gets wrong. The story is not "AI replaces engineers." The story is "AI replaces the *bottleneck of engineer time*." Engineering judgment (what to build, what to skip, what's worth shipping rough versus polishing) does not get cheaper. It might get more valuable. What gets cheap is the labor of typing the code. That used to be the limit. Now it isn't.

A handful of consequences fall out of that.

Tiny TAMs become buildable. A "total addressable market" too small to justify the engineer-weeks is not too small to justify a weekend. There's exactly one HOA-management SaaS in the country that serves Upstate South Carolina specifically (there isn't, actually, but you see where I'm going). The HOAs hate the national tools, the national tools can't justify customizing for them, and a builder with an autonomous cluster can spin one up in a week that's better, cheaper, and locally serviced. The barrier was always the cost of the build, not the size of the market. The build cost just collapsed.

SaaS unbundles. Big SaaS companies are priced to amortize the engineering team that built them. That price is now an arbitrage opportunity. You can build the slice of the SaaS your customer actually uses for one to two orders of magnitude less, charge less than the incumbent, and be the local face the incumbent can never be. We have customers right now selling Chipp-hosted agents at 90% margins on top of us, to enterprises whose previous spend was on roll-your-own engineering teams. None of these customers are software people. They're domain people who learned how to describe a feature.

Every engineer becomes a manager. Not in the headcount sense: most companies are about to have *fewer* engineers, not more. In the cognitive sense. The day-to-day work of a senior engineer is becoming what a senior engineer's day used to look like in the rare moments when they had a productive intern. You assign tickets, you review the work, you push back on the bad calls, you absorb the merge. The agent does the typing. If you've been a strong manager and a mediocre coder, this is your moment. If you've been a strong coder and a weak manager, you have homework.

What hasn't changed

I'm going to be honest about the limits, because the maximalist version of this story is wrong and the people selling it are about to get a lot of folks hurt.

Autonomous agents fail. They fail about 20-30% of the time at Chipp, even on tickets we've tuned the system for. When they fail, the failure mode is usually one of three things: the prompt didn't have enough context, the context window overflowed and the agent forgot what it was doing, or the agent hit a class of problem (cross-cutting performance work, ambiguous product calls, anything requiring you to hold the whole system in your head) that the model genuinely cannot do yet.

The first two are fixable with better engineering. We've been chipping away at them for a year. The third is a model problem, and you're at the mercy of Anthropic's release schedule.

There's also a platform-risk story that nobody likes to talk about. Right now, Anthropic's models are the best for coding, by a margin. If you build your business on top of Claude, like we have, Anthropic eventually owns your margin. That's the deal you're in. The defense against that is *distillation*: training your own smaller model on the outputs of the frontier model, locking in the parts of your workflow that won't change for a year. We've been distilling for two months. It's the long game, and it's the part of this that the AI labs are going to lobby to make illegal, because it's the only thing that prevents a one-lab monopoly from owning the entire software industry. Watch that fight. It's the most consequential AI policy debate of the decade and almost nobody is paying attention.

What we're building

Alchemist is the cluster I just described, packaged as a product anyone can use.

You describe what you want. We deploy an autonomous engineering team (research agent, implementation agent, code-review agent, documentation agent, deploy agent) that builds it. The output is a real codebase, in a stack we've spent six figures of token spend tuning (Deno on the server, Svelte on the client, Cloudflare for delivery), running on infrastructure we've made cheap. You can use the platform forever, or you can eject: pull the GitHub repo, take the code, run it yourself, and stop paying us. We optimized for that on purpose. If we ever raise prices into a corner, you walk away and we deserved it.

That's the bet. The bet is that the same way 1450 didn't end up being about the press itself but about everything the press *uncoupled*, the next decade isn't about coding agents. It's about everything that comes apart once code stops being scarce.

The companies that are going to be huge in 2030 are the ones building right now, while everyone else is still arguing about whether the agents really work. The agents really work. We've been running them in production for two months. The window where this is a contrarian take is short.

If you want to be early, join the waitlist.

If you want to understand the engineering (the context-engineering tricks, the self-healing loop, the bash harness, the distillation moat) I'm writing a series of posts that goes deep on each piece. The series picks up where this one ends.

We'll see you on the other side.

-- Hunter Hodnett, co-founder, Alchemist AI

Catalyst Medical is a real clinic with real patients. Six weeks ago, every call going to their main line started getting picked up by an AI agent — on the first ring, in the patient's language, with their full chart context, fully HIPAA-compliant.

The team didn't quit answering the phone. They just stopped having to.

On Wednesday, May 6, we're running a free workshop to show you exactly how it works — how we built it, how we deploy it across web, text, and phone, and how you can ship the same thing for your own business or your clients this week.

**Reserve your spot →**

Hold Music Is a Choice Now

Here's the number worth memorizing: ~60% of customers would rather talk to AI than sit on hold.

Not someday. Right now. Your customers already prefer the bot — as long as the bot is good. The businesses that figured this out aren't bragging about it. They're just answering every call, every text, every chat, 24/7, in any language, while their competitors are still staffing a phone tree.

The gap is widening every month. Most of your competitors haven't built it yet. That's the window.

One Brain. Every Channel.

The mistake teams make is building three different bots — one for the website, one for SMS, one for the phone line. Then nothing matches and everything drifts.

The right way: build the agent once. Knowledge, tone, escalation rules, tools. Then deploy that single brain to:

• Web — embedded chat on your site
• Text — real SMS into the same agent
• Phone — a real number people can actually call

Same brain. Same voice. Same answers. One source of truth.

How Voice Actually Works (And Why Most People Get It Wrong)

There are two ways to build voice AI, and the choice shapes everything else.

Realtime — one open WebSocket. Audio in, audio out, sub-second. Feels human. Handles barge-in. You interrupt the agent, it stops mid-sentence like a person would.

Pipeline — Speech-to-text → LLM → Text-to-speech. More moving parts, more latency, but you get to pick every component. Want a specific voice clone? A specific model for a specific intent? A multilingual TTS? Pipeline gives you the knobs.

We'll show you both, walk through the LiveKit-powered stacks Chipp exposes, and tell you which one to pick for which job.

The Phone Part People Skip

You don't replace your phone number. You forward it.

Your existing carrier — Verizon, RingCentral, whoever — already has call forwarding built in. You point it at the AI's number. Done. The AI answers. When someone needs a human, the agent transfers — either by keyword ("talk to a person") or because the model decided escalation was warranted based on what it heard.

International numbers, too. Local presence in dozens of countries, one global agent.

HIPAA Isn't a Blocker

Catalyst proves it. BAA-eligible providers across the whole stack. PHI-redacted logs. Encrypted recordings. Access controls.

If you've been told AI support won't work in healthcare, finance, or legal — you've been told wrong. We'll show you the exact stack we use for Catalyst, and which providers you can name on a BAA today.

The Loop That Actually Improves the Agent

Recordings and chat logs aren't a compliance checkbox. They're the raw material.

Here's what we did at Catalyst this morning: reviewed an overnight chat, found a question the agent answered weakly, opened Alchemist, updated the agent, redeployed. Total time: under ten minutes. The next caller got the corrected answer.

That loop — read → fix → redeploy — is the difference between a bot that decays and an agent that gets sharper every week. We'll show you the actual chat from this morning live on the call.

What You'll Walk Away With

A live demo of Catalyst's agent — answering web chats, text messages, and phone calls on stage.

The voice stack picker — exactly which providers (STT, LLM, TTS, voice clone) to use for which job, and why.

The deployment playbook — how to set up call forwarding from your existing carrier, provision an international number, and route calls between AI and human.

The improvement loop — how to feed real conversations back into Alchemist so the agent gets better every week.

The HIPAA-ready blueprint — every provider in our stack is BAA-eligible. We'll name names.

Who This Is For

• Founders and ops leads drowning in support volume and tired of hiring around it
• Agencies and consultants ready to add voice AI as a service line your clients are about to ask for
• Healthcare, finance, and legal teams who've been told AI support isn't an option for them — it is

The Bigger Picture

The same shift happening in marketing (agencies becoming AI agencies) is happening in support. The teams that build their AI support agent now will look up in twelve months and realize they've quietly captured every call, every text, every chat — while their competitors are still arguing about whether to try it.

Catalyst started with web chat and then phone. We'll show you everything we did.

AI Customer Support That Actually Picks Up Wednesday, May 6, 2026 · 11:00 AM – 12:00 PM CDT Free · Online

**Reserve your spot →**

USB-C ended that. One cable, one port, one protocol, and overnight, every device manufacturer's hardware became compatible with everyone else's. The standard didn't make any individual device better. It made the *ecosystem* better.

The Model Context Protocol (MCP) is doing the same thing for AI agents. Before MCP, every framework had its own format for tools. Each integration was bespoke; each integration was three integrations. After MCP, you write one server, and any MCP-compatible client. Claude Code, Cursor, Goose, increasingly anything, can use it.

This post is the tutorial I wish I'd had when I started. By the end of 30 minutes you'll have a working custom MCP server, registered to Claude Code, with one real tool that does something useful. Then we'll talk about what to build *after* the tutorial.

If you want the conceptual case for why MCP matters at all, the manifesto covers it. This post assumes you're convinced and want to build.

Part 1: What MCP actually is

A language model only does one thing: output text. Every demo of an "AI agent", the ones that browse the web, query a database, send Slack messages, those are not the model doing anything. They're the model emitting *text*, and software around the model interpreting that text as an instruction.

The conventional way for the model to describe what it wants is a *tool call*. The model emits something like:

I want to call a tool named "read_file" with the argument {"path": "src/index.ts"}

The framework around the model parses that, runs the actual `read_file` tool on your machine, gets the result, and feeds the result back into the model's next turn. The model now "knows" the contents of `src/index.ts`. It didn't read the file. The framework read the file. The model just got text saying "here's what was in it."

This is the loop. Every interesting capability of every modern AI agent reduces to this loop.

"The model never executes anything. It just describes what it wants executed, and software outside the model does the executing." -- Hunter Hodnett, Chipp CTPO

MCP is the standardized way for the framework to find out *what tools exist*, *what parameters they take*, and *how to call them*. Before MCP, every framework had its own format. After MCP, you build a small server that conforms to the protocol, and any MCP-compatible client can use it.

The protocol itself is conceptually simple: an MCP server speaks JSON-RPC over either standard input/output (for local servers) or HTTP (for remote servers). It exposes a few methods, `tools/list` to enumerate what's available, `tools/call` to invoke one. Claude Code calls those methods on your behalf.

You don't need to memorize any of this. The TypeScript SDK handles the protocol details for you. You just declare your tools, write the implementations, and the SDK does the JSON-RPC plumbing.

Part 2: What we're building

To make this tutorial useful instead of abstract, we'll build a real MCP server: a database query tool for a hypothetical app's `users` table.

In 30 minutes, you'll have:

• A local MCP server written in TypeScript.
• A `query_users` tool the agent can call to look up users by email or ID.
• A safe-column allowlist so the agent never accidentally exfiltrates passwords.
• The server registered with Claude Code so you can use it interactively.

This is the shape of every internal MCP server we've built at Chipp. By the end you'll know how to write your own for your billing system, your job queue, your feature flag store, anything where a custom tool would beat a generic one.

Part 3: Setup (5 minutes)

Make a fresh directory and initialize a Node project. We'll use TypeScript and the official MCP SDK.

mkdir my-first-mcp && cd my-first-mcp
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx

Create a minimal `tsconfig.json`:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "node",
    "esModuleInterop": true,
    "strict": true,
    "outDir": "dist"
  },
  "include": ["src/**/*"]
}

And add a `"type": "module"` to your `package.json` so we can use ESM imports.

That's the entire setup. You're done.

Part 4: The smallest working server (10 minutes)

Create `src/server.ts`:

import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

// 1. Define the input schema for the tool.
const QueryUsersArgs = z.object({
  email: z.string().optional(),
  id: z.string().optional(),
});

// 2. Define the tool itself.
const QUERY_USERS_TOOL = {
  name: "query_users",
  description:
    "Look up a user from the application's users table. " +
    "Pass either `email` or `id`. Returns the user's id, email, name, " +
    "and account_status. Sensitive columns (password_hash, " +
    "oauth_tokens) are filtered at this layer and never exposed.",
  inputSchema: {
    type: "object",
    properties: {
      email: { type: "string", description: "Email address to look up" },
      id: { type: "string", description: "User ID to look up" },
    },
  },
};

// 3. The fake "database" so this tutorial runs standalone.
const FAKE_DB = [
  { id: "u_1", email: "alice@example.com", name: "Alice", account_status: "active" },
  { id: "u_2", email: "bob@example.com", name: "Bob", account_status: "suspended" },
];

// 4. Boot the server, register handlers.
const server = new Server(
  { name: "my-first-mcp", version: "0.1.0" },
  { capabilities: { tools: {} } }
);

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [QUERY_USERS_TOOL],
}));

server.setRequestHandler(CallToolRequestSchema, async (req) => {
  if (req.params.name !== "query_users") {
    throw new Error(`Unknown tool: ${req.params.name}`);
  }
  const args = QueryUsersArgs.parse(req.params.arguments);
  const user = FAKE_DB.find(
    (u) => (args.email && u.email === args.email) || (args.id && u.id === args.id)
  );
  return {
    content: [
      {
        type: "text",
        text: user ? JSON.stringify(user, null, 2) : "No user found.",
      },
    ],
  };
});

// 5. Wire stdio transport.
const transport = new StdioServerTransport();
await server.connect(transport);

That's the full server. About 50 lines. Save it.

You can run it locally to make sure it doesn't crash:

npx tsx src/server.ts

It'll print nothing because it's waiting for JSON-RPC messages on stdin. Hit Ctrl-C.

Part 5: Register with Claude Code (3 minutes)

Tell Claude Code about the server by editing `~/.claude.json` (or your project's `.mcp.json` if you want it scoped to one project):

{
  "mcpServers": {
    "my-first-mcp": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/my-first-mcp/src/server.ts"]
    }
  }
}

Replace `/absolute/path/to/` with the real path. Restart Claude Code.

Verify the server is loaded:

$ claude
> /mcp

You should see `my-first-mcp` in the list, with one tool available.

Part 6: Try it out (5 minutes)

In a Claude Code session, ask:

Look up the user with email alice@example.com and tell me their account status.

The agent should call `query_users` with `{"email": "alice@example.com"}`, get back the JSON for Alice, and report that her account is active.

Try the negative case:

Look up the user with email nobody@example.com.

The agent should call the tool, get back "No user found.", and report that.

Congratulations, you have a working MCP server. The protocol plumbing is handled. The tool is yours.

Part 7: The discipline that makes this useful (7 minutes)

Now the part that separates a tutorial MCP from a production MCP.

Tool descriptions are prompt engineering

The model decides whether to call a tool *based on the description*. Not the name. Not the parameters. The description.

The description we wrote above is honest but generic. A production version of the same tool would look more like this:

const QUERY_USERS_TOOL = {
  name: "query_users",
  description:
    "Look up a user from the application's users table. " +
    "Pass either `email` (case-insensitive, exact match) or `id` (UUID). " +
    "Returns: id, email, name, account_status. " +
    "Sensitive columns (password_hash, oauth_tokens, payment_methods) " +
    "are filtered at this layer and are NEVER exposed in any session. " +
    "Use this when investigating customer-reported issues, debugging " +
    "auth problems, or verifying user state. " +
    "Do NOT use this to enumerate users (no list/scan capability) or " +
    "to modify users (read-only). For mutations, use `update_user` instead.",
  ...
};

That description does five things the original didn't:

1. Tells the model exactly what data shape to expect.
2. Explicitly names the columns that are filtered out, so the model doesn't ask for them.
3. Tells the model when to use the tool (and when not to).
4. References sibling tools the model should use instead for related operations.
5. Sets expectations about behavior (case-insensitive, exact match, etc.) so the model doesn't guess.

This level of detail is the difference between an MCP that the agent calls correctly and one that the agent calls in confusion. The investment compounds, every session that uses the tool benefits.

A heuristic I use: if the model would have to guess about anything, the description is too short. Add a sentence.

Have Claude write your descriptions

The model is much better at writing descriptions for itself than you are. Once you've drafted the implementation, paste the schema into Claude Code and say *"Write a tool description for this MCP tool. The agent will read this description to decide when to call the tool. Be specific. Mention edge cases. Tell the agent when not to use this tool."*

The first draft is usually 80% of the way there. Tighten and ship.

Filter sensitive data at the MCP layer

This is the big one. Anything you don't want the agent to see should be filtered out at the server layer, not at the prompt layer.

If you tell the agent "don't look at password hashes" via a system prompt, the agent might still look at password hashes when it's confused. If your MCP server *cannot return* password hashes, because the SQL has a hardcoded column allowlist that doesn't include them, the agent literally cannot see them. There's no failure mode where it accidentally gets exposed.

We give our autonomous agents read access to production databases. The reason this is safe is that the database MCP server has hardcoded column allowlists per table. The agent can query `users`, but the only columns the MCP server will return are `id, email, name, account_status, created_at`. Everything else is filtered at the server. Even if the agent goes off the rails and asks for `password_hash`, the MCP server returns the allowlisted columns and ignores the rest.

This is how you ship MCP servers that touch production data without losing sleep.

Restart Claude Code when you change the server

The most painful gotcha. Claude Code starts the MCP server process *once*, at session start. If you change the server's source code mid-session, your edits won't take effect until you restart.

You will, at some point, edit your MCP server, run it, find a bug, fix the bug, and watch Claude Code call the *old version* of the tool. Then you'll spend an hour debugging "why isn't my fix working" before you remember the gotcha.

When in doubt: restart Claude Code. There's a cheaper way (the `/mcp` command lets you reconnect), but the brute-force restart is the muscle memory worth building.

Don't `console.log` from your MCP server

Local MCP servers communicate with Claude Code over stdio in a structured JSON-RPC format. If you `console.log` anything, that text gets injected into the protocol stream, the framework chokes on the malformed bytes, and your tool stops working in confusing ways.

Use a real logger that writes to *stderr*, not stdout. The MCP SDK has examples. The pain of debugging a stdio-corrupted MCP server is the kind of pain you feel only once before you internalize the rule.

Part 8: Beyond the Tutorial (What to Actually Build)

The fake-database MCP we just built is a tutorial, not a production system. Here's what to build *after* this tutorial, in order of leverage.

A custom database MCP for your real database

Replace the `FAKE_DB` array with a real connection to your application's database. Hardcode the column allowlists per table. Add tools for the queries you actually need, `query_users`, `query_orders`, `query_subscriptions`, whatever your domain requires.

This will be the most-used MCP in your cluster. We dispatch it on almost every Bug Bot ticket.

A custom browser MCP

The single highest-leverage MCP in autonomous development. (Why →)

Wrap a local Chromium instance via the Chrome DevTools Protocol. Expose tools for navigate, screenshot, click, fill, console-log retrieval. Bake in your dev login flow as its own tool, `browser_dev_login(role: "free" | "enterprise" | "admin")` that bypasses your auth flow with seeded test credentials.

That last tool is the differentiator. Off-the-shelf browser MCPs are generic. The MCP we run for Chipp knows how to log in as any user role without going through OAuth. That domain knowledge is what makes verification fast enough to be useful in an autonomous loop.

A custom log-drain MCP

Wrap your log aggregator (we use Loki). Expose `query(labels, time_range)` and a higher-level `user_breadcrumbs(user_id, time_range)` that pulls a user's recent interactions before an error fired.

The `user_breadcrumbs` tool is what lets the agent reconstruct the user journey that led to a bug, and propose fixes that match real usage, not synthetic edge cases.

A custom cron / job MCP

If you have any kind of background job system, wrap it. Tools for *list jobs*, *query job status*, *trigger a job manually*. The agent will use these to debug job failures without you having to baby-sit.

Don't roll your own when an official one exists

For Stripe, GitHub, Cloudflare, Supabase, Notion, use the official MCPs. The vendors maintain them. They keep up with API changes. They handle auth.

Where to roll your own: anything internal to your codebase, anything where the off-the-shelf MCP is too generic to give the agent the right context (we found this true for databases, off-the-shelf DB MCPs hallucinated column names constantly).

Part 9: The mental model to keep

Without MCP, you have a model that emits text. That's it. It can't read your code, can't look at your screen, can't query your database, can't verify anything it produces.

With MCP, the model can interact with the world. It can check its own work. It can correct its own mistakes. It can chain together capabilities that no single component of your system would have alone.

That's not an upgrade. That's a phase transition.

Every additional MCP server you build is more *senses* the agent has. The agent that ships your code in 2027 will have access to twenty MCP servers and will navigate them as fluently as you navigate your filesystem. The teams that build those servers earliest will have agents that ship the most reliable code, because their agents will have the most ways to verify themselves.

Build one this weekend. Then build the next one. The cluster works as well as your tools let it.

[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)

If you want the conceptual case for MCP, the manifesto covers why MCP is one of the five pillars of autonomous development.

If you want to see how MCP fits into a production cluster, read Building a Self-Healing Bug Bot. Component 4 walks through the four MCPs every Bug Bot setup needs.

If you want the foundational discipline for managing the context MCPs add, read Context Engineering.

Some knowledge is too big to put in `CLAUDE.md`, it would bloat every context window with information you only sometimes need. Some knowledge requires *work* to retrieve, not just to read. Some tasks are fundamentally side quests: you don't want them polluting your main agent's context, but you do want them done.

Claude Code has two features for this: skills and sub-agents. They look superficially similar, both let you give Claude specialized capability, and most people I talk to use them interchangeably for a few weeks before they figure out the actual difference.

The actual difference is one sentence:

Skills are knowledge the agent reads while it's working. Sub-agents are work the agent delegates to a separate instance.

Once you internalize that, the rest writes itself. But it took me a quarter to figure out, so let me save you the time.

What a skill is

A skill is a markdown file with a name, a description, and a body. The body is whatever you want, usually instructions, examples, or domain-specific rules. The description is what Claude reads to decide whether to *invoke* the skill at all.

When the description matches what the user asked for, the skill loads. The body of the skill becomes part of the context window for the rest of that session, and the agent has it as reference while it works.

The mental model is a cheat sheet on your desk. You're working at a desk. There's a sticky note on the desk. While you work, you glance at the sticky note for the formulas you can't remember.

I have a skill called `chipp-design` that contains every visual convention of the Chipp brand: our color tokens, our spacing scale, our component library, when to use which animation, how to do glass-morphism in a way that's still legible. The description tells Claude: *"Build UI components and pages following the Chipp brand design system for Svelte 5. Use this skill when creating Svelte components, pages, or UI elements."*

When I ask the agent to build a settings page, the description matches, the skill loads into context, and the agent now has the entire design system as reference. Without the skill, the agent would invent tokens, hardcode hex colors, and ship something that doesn't match the rest of the platform. With it, the output looks like our team built it.

That's a skill working at its best. The cost: tokens. The skill body, which can be substantial, is now occupying space in my context window. Every other tool call has less room.

What a sub-agent is

A sub-agent is a separate Claude Code session that the main agent spawns, gives a starting prompt, and waits for a result. The sub-agent has its own context window. It runs its own tool calls. When it's done, it sends a summary back to the calling agent, and only the summary lands in the main context window.

The mental model is sending an intern to the library. You're sitting at your desk. You realize you need to know something obscure, say, what's the current state of all our Kubernetes pods. Rather than walking to the library yourself, you send an intern. They go off, do the work, come back, and hand you a one-page summary. You absorb the summary in seconds. The intern absorbed every page of the encyclopedia.

I have a sub-agent called `infra-ops`. Its system prompt knows everything about our Kubernetes cluster: which `kubectl` commands are safe, where the production logs live, how to read deployment YAML, what's normal versus alarming. When the main agent runs into something like *"pods are restarting in production,"* it doesn't try to investigate itself, it spawns the `infra-ops` sub-agent.

The sub-agent fills its own 1M-token context window with raw `kubectl` output, log excerpts, deployment manifests. It correlates them, finds the actual issue, and reports back to the main agent: *"Pods are OOM-killing because the last deploy lowered the memory limit too aggressively. Recommend bumping `requests.memory` from 512Mi to 1Gi."*

That two-sentence summary lands in my main context window. The 950k of garbage that was needed to derive it stays in the sub-agent's window, where it can't pollute anything.

The token math

Both tools cost tokens. They don't cost them in the same way.

A skill spends from your *current* context budget. The skill body is loaded into the active session's context window. If your skill is 8,000 tokens long, you have 8,000 fewer tokens for everything else this session. If you load three skills, that's 24,000 tokens gone.

A sub-agent spends from a *separate* context budget. The sub-agent has its own window, its own tool calls, its own model invocations. From the calling agent's perspective, it spent the cost of one tool call: *"spawn sub-agent, here's the prompt, get back a summary."* The sub-agent might have spent 150,000 tokens internally to produce that summary, but the calling agent doesn't see them.

This matters more than you'd think. On a complex task, the main agent might spawn five sub-agents over the course of its run. Each sub-agent fills 100,000-200,000 tokens of its own context window doing real work. The main agent, meanwhile, accumulates the five summaries, maybe 5,000 tokens total. The main agent stays nimble. It doesn't compact. It doesn't lose track of why it started the task.

If you tried to do the same work with five skills loaded into the main agent, you'd have to load all the relevant context for all five domains into the same window. The main agent would either compact halfway through or run out of budget completely.

This is the central trick. Skills concentrate context in the main agent. Sub-agents distribute context across separate agents.

"If you'd describe the task as 'go figure out X and tell me,' it's a sub-agent. If you'd describe it as 'while you work, remember X,' it's a skill." -- Hunter Hodnett, Chipp CTPO

When to reach for which

The decision rubric is simpler than I expected once I had it.

Use a skill when:

• You need the knowledge *while the agent is actively coding*, referencing it dozens of times during the work.
• The knowledge is short enough that loading it doesn't blow the budget.
• The work is in the agent's main domain (writing the feature, not debugging infra).

Examples: design systems, code style guides, API conventions, common pitfalls for the current subsystem.

Use a sub-agent when:

• The task is *fact-finding* or *side investigation*, read a bunch of stuff, return one insight.
• The task involves a lot of tool calls that the main agent doesn't need to see.
• The task is in a separate domain (debugging Kubernetes from a feature-development session).
• The task can fail without affecting the main work.

Examples: debugging production issues, researching how a third-party library works, auditing the codebase for instances of a deprecated pattern, summarizing a long document.

A test that almost always works: if you would describe the task as "go figure out X and tell me," it's a sub-agent. If you'd describe it as "while you work, remember X," it's a skill.

Real examples from Bug Bot

Three live examples from our autonomous cluster.

`chipp-design` (skill)

Loads when the agent is doing UI work. About 6,000 tokens of design rules, component library reference, and scar-tissue notes about CSS gotchas. Description: *"Build UI components and pages following the Chipp brand design system for Svelte 5."*

The agent reads it dozens of times during a UI ticket, checking spacing tokens, color palette, component conventions. Loading it as a skill means the reference is *there* the whole time, not behind a tool call.

If we tried to handle this with a sub-agent, *"go figure out our design system and tell me what to use"*, the agent would have to dispatch the sub-agent, wait for the summary, and then realize it needed more detail and dispatch again. Skill is the right tool.

`infra-ops` (sub-agent)

Loads when the main agent has a production issue and needs investigation. The sub-agent has its own runbook (kubectl commands, log query patterns, common failure modes), its own tools (kubectl MCP, Loki MCP), and its own context window.

The main agent dispatches it with one tool call: *"Investigate why pods restarted in the last hour."* The sub-agent runs 47 tool calls, fills 200k of context window, correlates everything, and returns a one-paragraph diagnosis.

If we tried to handle this with a skill, *"here's everything about our K8s cluster, now investigate"*, the main agent's context would fill up with raw kubectl output and lose its grip on the actual ticket. Sub-agent is the right tool.

`feature-deep-dive` (sub-agent)

Loads when the main agent needs to understand how an existing feature works before modifying it. The sub-agent reads the feature's code, related tests, recent git history, and any relevant docs, then returns an architecture summary.

The main agent gets the summary in its context, applies it to the modification work, ships the change. The 100k of code-reading the sub-agent did doesn't pollute the main session.

This is one of our most-dispatched sub-agents. Almost every non-trivial feature ticket dispatches it as the first step.

Anti-patterns I've shipped and regretted

Three patterns I've burned tokens learning are wrong.

The omnibus skill

I had one called `everything-about-our-platform` that loaded a 30,000-token document with our entire architecture. It was easier than thinking about which skill to write. The agent would load it for *every* task, including ones that didn't need it, and we'd lose 30,000 tokens of budget every session.

Splitting it into focused skills (`chipp-billing`, `chipp-design`, `chipp-routing`, `chipp-auth`) meant only the relevant 5,000 tokens loaded at a time. Big improvement.

If your skill description starts with *"general knowledge about…"*, you're building an omnibus. Split it.

The sub-agent for trivial work

Spawning a sub-agent has overhead, a separate model invocation, the round-trip of starting a new session, the cost of sending the initial prompt. If the task is small, just do it inline.

Sub-agents pay off when the task would fill 50,000+ tokens of context. They cost more than they save when the task would fill 500.

Heuristic: if you'd be embarrassed to interrupt a colleague to ask the question, don't dispatch a sub-agent for it.

Skills used as sub-agents

This is the most common mistake I see. Someone wants the agent to *"go check the database for orphaned records."* They write a skill called `database-investigation` with instructions and example queries. The skill loads, then the *main agent* runs the queries, and now its context window is filling up with raw database rows.

They wanted the work done elsewhere. They gave themselves a cheat sheet instead.

The fix is a sub-agent: spawn one, let it run the queries, have it return *"found 47 orphans, here are the IDs."* Main context window stays clean.

The pattern to internalize: skills are reference material the main agent uses to do work itself. Sub-agents are work delegated to a separate agent, with only the result coming back.

The simplest decision

If you want the *agent* to know something, write a skill.

If you want *someone else* to know something, spawn a sub-agent.

That's it. That's the whole post.

The deeper the autonomous cluster gets, and the Bug Bot pipeline leans on both heavily, the more these two patterns become the basic structural elements of every workflow. We use both, constantly. The skills carry the patterns we want consistent across all our work. The sub-agents carry the heavy lifting that would otherwise crush our main agent's context.

Get this distinction right and your context budget stops being the bottleneck on everything you ship.

[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)

If you want the foundational discipline these patterns build on, read Context Engineering: The Skill That Turns Claude Into a Production Co-Developer.

If you want the architecture for managing skills and sub-agents at scale, read CLAUDE.md Architecture.

If you want to see skills and sub-agents at work in a production cluster, read Building a Self-Healing Bug Bot.

Agentic systems are at the same place now. The shape of how to build production-grade autonomous workflows is becoming clear; the patterns are emerging across teams that have shipped real systems. They just don't have names yet.

This post names seven of them. Each one is a pattern we've battle-tested across two years of running our autonomous development cluster at Chipp. Each one solves a specific failure mode. Each one is portable to whatever stack you're building on.

You don't need all seven to start. Pick three. Implement them this month. The other four will become obvious once the first three are working.

Pattern 1: The Multi-Stage Pipeline

Problem: A single Claude Code session that tries to do everything (research, implement, review, document, push) runs out of context budget. The session compacts. The agent loses the thread. The output quality collapses.

Pattern: Split the work into independent stages. Each stage gets its own Claude Code session with a fresh context window. Stages communicate by writing markdown files to disk; the next stage reads only the file the prior one wrote.

Our pipeline at Chipp:

[Trigger] → [Phase 0: Doc retrieval] → [Phase 1: Research]
         → [Phase 2: Implement]   → [Phase 3: Code review]
         → [Phase 4: Docs update] → [Phase 5: Push to prod]

Each phase is its own Claude session. Phase 1's output is `plan.md`. Phase 2 reads `plan.md` (no other context) and writes the code. Phase 3 reads the diff (no other context) and reviews it. And so on.

Why this works: A single 1M-token context window can hold a lot, but it can't hold *everything* you want it to hold across an entire feature ticket. By the time the agent has read 30 files, queried logs, formed a hypothesis, written code, run tests, and reviewed its own diff, the window is full and the early reasoning has been compacted to a useless paragraph.

Splitting into stages gives each stage a fresh window. The stage that's writing code doesn't need to remember every file the research stage looked at, it just needs the plan. The plan is the *distilled* output of the research, and distillation survives where raw evidence wouldn't.

Implementation: Stage outputs are markdown files in a known location. The bash harness orchestrates the handoff. Don't try to do this with one long-running session and "memory." It will fail.

Anti-pattern: The temptation is to add more stages. Five is the right number for most pipelines. Don't go to ten. Each additional stage costs latency and a chance for handoff failure. If a stage isn't earning its place, merge it into a neighbor.

Pattern 2: Sub-Agent Dilution

Problem: Some investigations require *huge* amounts of context, reading thousands of lines of logs, running dozens of tool calls, correlating evidence across many sources. If you do this in your main session, you've burned the budget on context the main task doesn't need.

Pattern: Spawn a sub-agent. The sub-agent has its own context window. It does the heavy investigation. It returns a one-paragraph insight to the calling agent. The 950k tokens of evidence stay in the sub-agent's window, where they belong.

Our `infra-ops` sub-agent: When the main agent encounters something like *"pods are restarting in production,"* it doesn't try to investigate itself. It dispatches the `infra-ops` sub-agent. That sub-agent runs 47 `kubectl` commands, queries Loki, cross-references the deploy history, and returns: *"OOM-killing because the last deploy lowered the memory limit too aggressively. Recommend bumping `requests.memory` from 512Mi to 1Gi."*

That two-sentence summary is what lands in the main session. (Full pattern →)

Why this works: The mental model is *sending an intern to the library*. You don't want every page they read; you want the answer. Sub-agents give you the architectural shape to do exactly that.

Implementation: Define sub-agents in `.claude/agents/`. Each one is a markdown file with its own system prompt and tool list. Reference them in your root `CLAUDE.md` so the main agent knows when to dispatch which.

Anti-pattern: Don't dispatch a sub-agent for a task the main agent could finish in two tool calls. Sub-agents have overhead, a separate model invocation, the prompt round-trip, the deserialization of the result. They pay off when the task would otherwise fill 50,000+ tokens of context. They cost more than they save when the task is small.

Pattern 3: The Browser Verification Loop

Problem: The agent writes code that compiles, passes tests, and looks correct in the diff. None of that proves the code *works in a browser*. Buttons can render in the wrong color. Click handlers can throw runtime exceptions. API calls can fail. The agent doesn't know.

Pattern: After every code change, the agent spins up a dev server, opens a browser via the browser MCP, navigates to the affected page, takes a screenshot, reads the console logs, and verifies the change worked. If anything's wrong, the agent forms a new hypothesis and iterates.

The actual loop:

1. Code changes saved in worktree.
2. Dev server (already running on dedicated port) auto-reloads.
3. Agent calls `browser_navigate('localhost:5184/affected-page')`.
4. Agent calls `browser_screenshot()`. Reads the image (multimodal models *see* the screenshot).
5. Agent calls `browser_console_logs()`. Reads the console output.
6. If no errors, agent calls `browser_click('#confirm')` or whatever interaction tests the change.
7. Repeat screenshot + logs read.
8. If errors, the agent forms a hypothesis, edits the code, loop restarts.

Why this works: Most "AI ships bad code" stories are stories about agents that wrote plausible-looking code, never tested it, and pushed. The browser loop is the difference between "the agent thinks the code works" and "the agent has *checked* that the code works." Closing this loop is the single architectural change that turned our cluster from interesting demo to production system.

Implementation: Custom browser MCP wrapping a headless Chromium via the Chrome DevTools Protocol. Off-the-shelf browser MCPs work for prototyping. For production, build your own, bake in your dev login flow, your seed data, your test scenarios. The custom version is the difference between fast and slow autonomous verification.

Anti-pattern: Don't run the verification loop on a shared dev server. Each agent worker needs its own port (we use 5180-5187 for our 8-worker pool) so parallel agents don't fight for the same port. Each agent also needs its own git worktree so they don't step on each other's changes mid-loop.

Pattern 4: CLAUDE.md as Scar Tissue

Problem: The agent makes the same mistake on every session. You correct it interactively. The next session, the correction is gone, the agent doesn't remember what it learned in a different session. You're paying for the same lesson over and over.

Pattern: Treat your `CLAUDE.md` as a scar tissue document. Every time the agent makes the same class of mistake three times, stop the session, write a rule into `CLAUDE.md` that prevents it, and continue. Over months, your `CLAUDE.md` accumulates the real rules of your codebase, the ones you can only learn by getting bitten.

Why three strikes: Once is an outlier. Twice is suspicious. Three times is a pattern. Patterns are what `CLAUDE.md` is for. Adding a rule per mistake bloats the file with one-off lessons that dilute the load-bearing rules.

Why this works: `CLAUDE.md` loads in *every* session and survives compaction. It's the only place to put context that you want the agent to have *forever* without paying for re-discovery on every run. Every line in `CLAUDE.md` pays compounding dividends.

Implementation: Have the *agent* write the rules into `CLAUDE.md` for you. The model knows what kind of rule will register on its own future inference better than you do. When the agent makes a mistake, prompt it: *"Add a rule to `CLAUDE.md` that prevents this exact mistake. Cite the failure mode. Make it specific enough to act on."* Then read what it wrote and tighten it.

Anti-pattern: Aspirational `CLAUDE.md`s. Rules like *"always write clean code"* and *"prefer composition over inheritance"* are too vague to act on. The agent ignores them. Replace with specific, scar-tissue-grounded rules tied to real failure modes you've seen. (Full discipline →)

Pattern 5: The Auto-Load Table

Problem: Some context is too domain-specific to live in your root `CLAUDE.md` (it would bloat every session) but too cross-cutting to live in a single subdirectory `CLAUDE.md` (the rules apply across the codebase whenever a *topic* is mentioned, not whenever a *directory* is touched).

Pattern: At the top of your root `CLAUDE.md`, put a small markdown table mapping keywords to documentation files. When a prompt mentions any of the keywords, the agent reads the corresponding doc into context before starting work.

Our table at Chipp:

## Auto-load table

| Mention | Read |
|---|---|
| billing, stripe, payment, subscription | docs/billing.md |
| auth, login, session, oauth | docs/auth.md |
| websocket, realtime, streaming | docs/realtime.md |
| voice, livekit, transfer | docs/voice-agents.md |
| migration, schema, kysely | docs/db-migrations.md |

The keywords are inclusive, if a ticket mentions "stripe" *or* "subscription" *or* "billing," the agent loads `docs/billing.md`. The rules in that doc are far too specific to put in the root `CLAUDE.md` (Stripe API quirks, our shadow-billing system, the eight failure modes of webhook delivery), but they're load-bearing whenever the work touches billing.

Why this works: It scales the system's domain knowledge horizontally. You can add ten more rows to the auto-load table without inflating the per-session context cost, the docs only load when relevant. Every successful autonomous run that produces a useful insight about a subsystem can write a new doc and get a new row, and tomorrow's tickets get smarter.

Implementation: Put the table at the top of your root `CLAUDE.md`. Be conservative with keywords, false positives waste budget. Generate the docs lazily as you ship, don't try to write all the docs upfront. Use the doc-update phase of your pipeline (Pattern 1) to keep the docs current.

Anti-pattern: Don't load *every* doc on every session "just in case." That's the bloat that this pattern is designed to prevent. Trust the keyword match. If the agent fails to load a doc it should have loaded, the keyword list was wrong, fix the list, don't load everything.

Pattern 6: The Bash Harness Wrapper

Problem: Claude Code is non-deterministic. It can hang. It can run for hours. It can attempt commands you don't want it running. It can finish work and forget to push. Your business needs to be deterministic. Your tokens are limited. Something has to be the adult in the room.

Pattern: Wrap every Claude Code invocation in a bash script that supervises the session. The script enforces timeouts, kills hangs, bans dangerous commands, forces the final commit and push, cleans up worktrees, and writes outcome labels.

What our harness enforces:

• Idle kill: if no tool call fires for 5 minutes, kill the session. Catches hangs.
• Wall-clock timeout: `timeout 7200` (2 hours) caps runaways.
• Banned-flag grep: `git push --no-verify`, `git reset --hard`, `rm -rf` are aborted on detection.
• Forced commit + push: at the end of every session, check the worktree state and force the push if Claude forgot.
• Worktree cleanup: each run isolated; nothing leaks between workers.
• Outcome logging: every run writes a JSONL row to a fine-tuning archive. (Pattern 7.)

Why this works: The model is good at writing code. It's bad at managing its own time, recognizing when it's stuck, or cleaning up after itself. The harness handles those things deterministically so the model can focus on the work.

"An autonomous agent without a bash harness is an intern with no manager, no deadline, and an unlimited API budget." -- Hunter Hodnett, Chipp CTPO

Implementation: Bash, not Node or Python. Bash is the right language for wrapping Unix processes, subprocess management, signals, timeouts, pipes are all concise in bash and verbose in everything else. Bash is also debuggable in production (no compilation step) and Claude has more bash training data than any other shell language, so the agent can edit the harness too.

The skeleton is in the bug bot post. About 200 lines covers everything above.

Anti-pattern: Don't try to build the harness in your application stack. Don't make it a feature of your CI system. The harness is a deliberately tiny, deliberately separate piece of infrastructure. Keep it that way.

Pattern 7: The Outcome-Labeled JSONL Archive

Problem: Every autonomous session generates a record of how a frontier model approached a real task in your codebase. That's training data. If you don't capture it, it's gone forever. If you do capture it, you have the basis for fine-tuning a cheaper, specialized model on your own work, the kind of moat that compounds.

Pattern: After every autonomous run, append a JSONL row to a long-term archive describing the run, the stages, the token spend, the tool calls, the diff, and the outcome label.

Our archive row:

{
  "ticket_id": "billing-create-customer-null-pmt",
  "trigger_source": "grafana",
  "started": "2026-04-15T03:31:18Z",
  "finished": "2026-04-15T03:47:02Z",
  "stages": {
    "research": { "tokens": 412053, "tool_calls": 38 },
    "implement": { "tokens": 187234, "tool_calls": 23 },
    "review": { "tokens": 91482, "tool_calls": 12, "edits": 1 },
    "docs": { "tokens": 43210, "tool_calls": 4 },
    "push": { "tokens": 0, "tool_calls": 0 }
  },
  "outcome": "clean",
  "regressions_detected_24h": false
}

The `outcome` field is the label. `clean` means: review made ≤5 edits, all tests passed first try, no regressions detected within 24 hours of deploy. `messy` means anything else.

Why this works: Labeled data is the asset that produces fine-tuned models. Every successful autonomous run produces a labeled training row showing how a frontier model approached a real engineering task. After a quarter, you have thousands of rows. After a year, you have a dataset no other team can replicate, because it's specific to *your* codebase and *your* practice.

You may never train a model on this data. That's fine. The decision to *capture* it is one you make today. The decision to *use* it is one you can defer for years. But you can't decide to use data you didn't capture.

Implementation: One JSONL row per session. Append-only file in cheap storage (S3, R2, even disk for now). Label the outcome with whatever automated heuristics you have, review edit count, test pass rate, post-deploy regression detection. Don't try to label perfectly; the labels can be improved later.

Anti-pattern: Don't try to make this data structured beyond JSONL. JSONL is append-only, easy to grep, easy to load into training pipelines. SQL is overkill. NoSQL is a different kind of overkill. Just the file.

How to use these patterns

You don't need to implement all seven on day one. Most teams who try fail at exactly that, they read this post, they get excited, they try to build a 7-pattern cluster in two weeks, they fail at three of them, and they conclude none of it works.

The order I'd implement them in:

1. Browser verification loop (Pattern 3). Without this, you can't autonomy. Build it first. Even if you do nothing else from this list, build this.
2. Multi-stage pipeline (Pattern 1). The next biggest leverage. Splits your sessions, controls your context budgets, makes everything else possible.
3. Bash harness (Pattern 6). Once you have a pipeline, you need the supervisor. This is the difference between a hobby project and something you can leave running overnight.
4. CLAUDE.md as scar tissue (Pattern 4). Discipline, not infrastructure. Start practicing it on day one of using any of the others. The compounding starts immediately.
5. Auto-load table (Pattern 5). After you've shipped enough autonomous tickets to start writing real `/docs/` files. Premature otherwise.
6. Sub-agent dilution (Pattern 2). Once your main pipeline is hitting context-budget walls on the heavy investigations. Solves a real problem; not a problem you have on day one.
7. Outcome-labeled archive (Pattern 7). Nothing-to-lose pattern. Start it as soon as you have a pipeline. Even if you never use the data, you'll be glad you have it in a year when distillation becomes the obvious move.

Pick three. Build them this month. The next three become obvious once the first three are working.

What you actually get

A team running these seven patterns ships in a different category than a team running interactive Claude Code sessions, and a *radically* different category than a team still doing all-human engineering.

The numbers from our cluster, honestly:

• 20-30 production deploys per day on a two-person engineering team.
• 70-80% first-attempt success rate on autonomous tickets.
• Mean time from production error to fix in production: ~30 minutes, autonomously.
• Token cost per ticket: low double-digit dollars on a frontier model.
• Pull requests: zero.
• Pages we receive overnight: zero.

The patterns aren't magic. Each one solves a specific failure mode. Together they compose into a system where the failure modes don't compound, when one pattern hits its edge case, the others catch it.

The Gang of Four made OOP transferable by naming the moves. The seven patterns above make autonomous development transferable. Use them, name them, build on them. We'll be writing about the next batch as they emerge.

[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)

If you want the high-level case for autonomous development, read The Autonomous Development Manifesto.

If you want the implementation walkthrough of all seven patterns wired into one cluster, read Building a Self-Healing Bug Bot.

If you want the discipline that underpins every pattern in this post, read Context Engineering.

For the past 30 years, businesses have optimized for human customers: beautiful landing pages, SEO for Google searches, checkout flows designed for clicking and typing. But a new category of customer is emerging — one that doesn't use a mouse, doesn't read your carefully crafted copy, and processes transactions in milliseconds.

AI agents are here. And they have money to spend.

In 2026, AI agents are autonomously booking travel, ordering supplies, purchasing software licenses, and consuming API services — all without human intervention. If your business isn't set up to serve these customers, you're invisible to an entirely new economy.

This guide will show you exactly how to:

1. Make your business discoverable to AI agents
2. Accept payments programmatically using the Machine Payments Protocol (MPP)
3. Capture revenue from the fastest-growing customer segment on the internet

Whether you run a SaaS company, offer professional services through AI agents, or operate APIs that agents need to consume, this is your roadmap to the agentic economy.

Part 1: The Problem (And Why It Matters Now)

How Humans Buy vs. How Agents Buy

When a human wants to hire a graphic designer:

1. Google search: "freelance logo designer"
2. Click through portfolio websites
3. Read reviews, compare prices
4. Fill out contact form
5. Email back-and-forth
6. Send invoice, wait for payment
7. Total time: 3-7 days

When an AI agent needs a logo designed:

1. Query structured service directory
2. Parse pricing and capabilities from machine-readable format
3. Evaluate options based on programmatic criteria
4. Initiate payment via HTTP request
5. Receive deliverable with cryptographic receipt
6. Total time: 3-7 seconds

The difference isn't just speed — it's structure. Agents can't navigate your beautiful Webflow site. They can't interpret your "Contact us for pricing" page. They need:

• Machine-readable service descriptions
• Programmatic pricing information
• API-native payment flows

If you don't provide these, the agent moves on to a competitor who does.

Part 2: Making Your Business Discoverable to AI Agents

AI agents don't browse. They query. Here's how to show up in those queries.

Step 1: Implement Structured Metadata

Agents discover services through structured data, not prose. You need to tell them — in a format they understand — what you offer, how much it costs, and how to buy it.

For Service Businesses (Agencies, Freelancers, Consultants)

Add Schema.org Service markup to your homepage:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Service",
  "name": "Professional Logo Design",
  "description": "Custom logo design with 3 concepts, unlimited revisions, delivered in 48 hours",
  "provider": {
    "@type": "Organization",
    "name": "YourAgency",
    "url": "https://youragency.com"
  },
  "offers": {
    "@type": "Offer",
    "price": "500",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://youragency.com/api/services/logo-design"
  }
}
</script>

Why this works: Agents parse structured data to build service catalogs. When an agent searches for "logo design service," your offering appears with pricing, availability, and a direct API endpoint.

For SaaS and API Businesses

Create a machine-readable pricing page at `/pricing.json`:

{
  "service": "Image Generation API",
  "plans": [
    {
      "name": "Pay-per-request",
      "type": "usage-based",
      "price": {
        "amount": "0.02",
        "currency": "USD",
        "unit": "image"
      },
      "endpoint": "https://api.yourservice.com/generate",
      "authentication": "mpp"
    }
  ],
  "capabilities": ["1024x1024", "SDXL", "ControlNet"],
  "latency_p95": "2.3s"
}

Why this works: Agents evaluate API services based on price, latency, and capabilities. A structured pricing file lets them compare your service against competitors programmatically.

Step 2: Create an Agent-Optimized Landing Page

Agents don't care about your hero image. But they do read specific sections of your site. Optimize for agent parsers:

The "For AI Agents" Section

Add a dedicated section to your homepage:

## For AI Agents

**Service:** Professional copywriting
**Pricing:** $0.10 per word
**Turnaround:** 24 hours
**Payment Methods:** MPP (Stripe, USDC on Tempo)
**API Endpoint:** https://yourservice.com/api/orders
**Documentation:** https://yourservice.com/docs/agent-access

To place an order programmatically, send a POST request to our API endpoint with MPP payment credentials.

Why this works: Many agents are instructed to look for "For AI Agents" or "API Access" sections when evaluating service providers. This explicit signaling increases discoverability.

Step 3: Publish to Agent Directories

Several agent-focused service directories have emerged. List your business on:

• MPP Registry (https://mpp.dev/registry) — directory of MPP-enabled services
• Agent Marketplace (https://agentmarketplace.ai) — curated catalog for ChatGPT, Claude, and Gemini
• Tempo Service Directory — blockchain-native service discovery

Most directories require:

1. Structured service description (JSON-LD)
2. MPP payment endpoint
3. API documentation
4. Pricing information

Step 4: Implement Discovery Extensions (Optional but Powerful)

For advanced discoverability, implement the MPP Discovery Extension:

Add a `/.well-known/payment-methods` endpoint to your domain:

{
  "methods": ["tempo", "stripe"],
  "intents": ["charge", "session"],
  "services": [
    {
      "name": "Logo Design",
      "endpoint": "/api/services/logo-design",
      "price": {
        "amount": "500",
        "currency": "USD"
      }
    }
  ]
}

Why this works: Agents can auto-discover your payment capabilities and service catalog by querying a standard endpoint, similar to how humans discover your site through `robots.txt`.

Part 3: Accepting Payments from AI Agents with MPP

Discovery gets agents to your door. MPP lets them pay and transact instantly.

What is MPP?

The Machine Payments Protocol is an open standard that lets agents pay for services in the same HTTP request. No signup forms, no billing portals, no human intervention.

Traditional payment flow (human):

1. Browse service
2. Click "Buy Now"
3. Fill out payment form (name, email, card number, CVV, billing address)
4. Click "Submit"
5. Wait for confirmation email
6. Total: 3-5 minutes

MPP payment flow (agent):

1. Request service: `GET /api/service`
2. Receive payment challenge: `402 Payment Required`
3. Submit payment credential: `GET /api/service` + payment proof
4. Receive service + receipt
5. Total: 200 milliseconds

How MPP Works (Simple Explanation)

Think of MPP like a vending machine for the internet:

1. Agent requests a resource (like pressing a button)
2. Server says "That costs $1" (like the price display)
3. Agent pays (like inserting money)
4. Server delivers the resource (like the snack dropping)

The technical magic happens through HTTP 402 "Payment Required" — a status code that's been in the HTTP spec since 1997 but never had a standard implementation until now.

Implementation: Three Paths

Path 1: Stripe Integration (Easiest — Recommended for Most Businesses)

Best for: Businesses that want both crypto and traditional payment methods (cards, Apple Pay, etc.)

Time to implement: ~30 minutes with a developer Fees: Standard Stripe fees (2.9% + $0.30 for cards, blockchain fees for crypto)

How it works:

1. Sign up for Stripe and request "Machine Payments" access
2. Install the MPP SDK: ```bash npm install mppx stripe ```
3. Add payment middleware to your API endpoint: ```javascript import { Mppx, tempo } from 'mppx/server'; app.get('/api/logo-design', mpp.charge({ amount: '500', currency: 'USD' }), (req, res) => { // Payment verified automatically // Deliver service res.json({ orderId: '12345', status: 'processing' }); } ); ```
4. Deploy — Your endpoint now accepts payments from agents

What you get:

• Payments in USDC (stablecoin) or traditional payment methods
• Funds settle into your existing Stripe account
• Same fraud protection, reporting, and accounting tools you already use
• Automatic receipts and transaction records

Path 2: Direct Tempo Integration (Crypto-Native)

Best for: Businesses that want lowest fees and crypto-only payments

Time to implement: 2-3 hours with a developer Fees: Blockchain gas fees only (typically <$0.01 per transaction)

How it works:

1. Create a Tempo wallet to receive payments
2. Install Tempo SDK: ```bash npm install @tempo/mpp ```
3. Configure your endpoint: ```javascript import { TempoMPP } from '@tempo/mpp'; const mpp = new TempoMPP({ recipientAddress: '0xYourWalletAddress', network: 'tempo-mainnet' }); app.get('/api/service', async (req, res) => { const payment = await mpp.verifyPayment(req); if (!payment.valid) { return mpp.challengePayment(res, { amount: '500' }); } // Payment verified, deliver service }); ```

What you get:

• Instant settlement in USDC
• No intermediary fees
• Direct blockchain settlement
• Full control over payment flow

Path 3: Hybrid (Best of Both Worlds)

Best for: Businesses that want maximum flexibility

Accept both crypto (via Tempo) and traditional payments (via Stripe) from the same endpoint. Agents choose their preferred payment method.

const mppx = Mppx.create({
  methods: [
    tempo.charge({ currency: USDC, recipient: '0x...' }),
    stripe.charge({ apiKey: process.env.STRIPE_KEY })
  ]
});

Worked Example: From Zero to Agent-Ready in About an Hour

Scenario: You run a copywriting agency. You want agents to be able to order blog posts programmatically.

Before MPP:

• Agent finds your site
• Can't determine pricing (you have "Contact us")
• Can't place order (no API)
• Gives up, goes to competitor

After MPP:

1. Add structured data to homepage (~15 min)
2. Create `/pricing.json` endpoint (~10 min)
3. Install Stripe + MPP SDK (~5 min)
4. Add payment middleware to order endpoint (~20 min)
5. Deploy (~10 min)

Result:

• Agent finds your service via structured data
• Parses pricing programmatically
• Places order with payment in a single HTTP request
• Receives blog post draft + receipt in 24 hours

A paying customer your previous setup couldn't have served.

Part 4: Agentic Commerce for AI-Powered Service Businesses

If you've built an AI agent that provides professional services (legal research, data analysis, content creation, etc.), MPP is your fastest path to monetization.

The AI Services Business Model

Traditional SaaS: Build software → Charge subscription → Users operate software

Agentic Services: Build AI agent → Agent performs service → Charge per transaction

Examples:

• AI legal research agent charges $5 per case brief
• AI financial analyst charges $50 per market report
• AI graphic designer charges $100 per logo concept
• AI code reviewer charges $0.10 per pull request

Why MPP is Perfect for AI Service Businesses

1. No billing infrastructure needed — MPP handles payment in the API request
2. Micropayments work — Charge $0.01 per API call profitably
3. Instant settlement — Get paid in seconds, not Net 30
4. Agent-to-agent commerce — Your AI agent can pay other AI agents for sub-services

Implementation for AI Service Providers

Step 1: Wrap your AI agent in an API

app.post('/api/analyze-contract', async (req, res) => {
  const { contractText } = req.body;

  // Your AI agent does the work
  const analysis = await yourAIAgent.analyze(contractText);

  res.json({
    analysis,
    risksFound: analysis.risks.length,
    recommendation: analysis.recommendation
  });
});

Step 2: Add MPP payment requirement

app.post('/api/analyze-contract',
  mpp.charge({ amount: '5.00', currency: 'USD' }),
  async (req, res) => {
    // Payment automatically verified before this runs
    const { contractText } = req.body;
    const analysis = await yourAIAgent.analyze(contractText);
    res.json({ analysis });
  }
);

Step 3: Publish to agent directories

List your AI service on MPP Registry, Agent Marketplace, and relevant directories with:

• Service description: "AI-powered contract analysis"
• Pricing: "$5 per contract"
• Endpoint: `https://yourservice.com/api/analyze-contract`
• Payment: "MPP (USDC, Stripe)"

Step 4: Watch the revenue flow

Other agents (ChatGPT, Claude, custom business agents) discover your service and start sending paid requests automatically.

Part 5: Common Questions and Concerns

"Isn't this just for tech companies?"

No. Any business that can be described programmatically can use MPP:

• Freelance designers → API endpoint for design requests
• Consulting firms → Programmatic access to expert analysis
• Data providers → Pay-per-query access to datasets
• Content creators → Automated content licensing

If you can deliver value digitally, you can accept payment via MPP.

"Do I need to understand blockchain?"

No. If you use Stripe integration, you never touch cryptocurrency. Stripe handles all crypto conversions and settles USD into your bank account, just like regular card payments.

If you do want to accept crypto directly, you just need a wallet address (like an email address for money). The SDKs handle everything else.

"What about fraud and chargebacks?"

MPP payments are cryptographically verified, which means:

• No chargebacks (blockchain transactions are final)
• No payment disputes (proof of payment is mathematically certain)
• No card testing fraud (no card numbers involved)

For Stripe SPT (Shared Payment Token) payments, standard Stripe fraud protection applies.

"How do I handle refunds?"

Refunds work differently for different payment methods:

Crypto payments: Send a reverse transaction to the customer's wallet Stripe payments: Use standard Stripe refund API

Most agent transactions don't require refunds because the service is delivered instantly and the payment is pre-verified.

"What if an agent sends the wrong amount?"

The MPP protocol includes amount verification:

• Server specifies required amount in challenge
• Client payment must match or exceed amount
• Server rejects insufficient payments automatically

You never deliver a service without receiving the correct payment.

Part 6: The Implementation Checklist

Ready to make your business discoverable and sellable to AI agents? Here's your step-by-step checklist:

Discovery Checklist

• Add Schema.org Service markup to homepage
• Create machine-readable pricing page (`/pricing.json`)
• Add "For AI Agents" section to website
• Publish to MPP Registry
• Publish to Agent Marketplace
• Implement `.well-known/payment-methods` endpoint (optional)

Payment Checklist

• Choose payment method (Stripe, Tempo, or Hybrid)
• Sign up for required accounts (Stripe account or Tempo wallet)
• Install MPP SDK
• Add payment middleware to API endpoints
• Test with mppx CLI tool
• Deploy to production
• Monitor transactions in dashboard

Optimization Checklist

• Document your API for agent developers
• Set up monitoring for agent traffic
• Create usage analytics dashboard
• Implement rate limiting for fair use
• Set up automated receipts and invoicing
• Configure webhook notifications for payments

Part 7: What Success Looks Like

Metrics to Track

Discovery Metrics:

• Agent traffic (check User-Agent headers for AI agents)
• API endpoint hits from agent IPs
• Structured data parse rates

Transaction Metrics:

• MPP payment requests
• Successful payment completions
• Average transaction value
• Payment method distribution (crypto vs. fiat)

Revenue Metrics:

• Agent-sourced revenue
• Revenue per agent
• Transaction frequency
• Month-over-month growth

Expected Timeline

• Week 1: Implementation and testing
• Week 2-4: Initial agent discovery and first transactions
• Month 2-3: Steady agent traffic growth
• Month 4+: Agent revenue becomes a meaningful part of your overall mix

What's Coming to Chipp

MPP support is on our roadmap. Soon, any agent or app you build on Chipp will be able to expose paid endpoints with structured discovery and HTTP-native payments built in — no SDKs to install, no payment middleware to wire up, no infrastructure to run.

Chipp already ships ACP support today, so the agents you build can search retail catalogs and complete checkouts on a consumer's behalf. MPP rounds out the other half of the picture: getting paid when *your* service is the one being consumed by an agent.

We'll update this post once MPP support lands.

The Bottom Line

The internet is being rebuilt for AI agents. Businesses that adapt now will capture a disproportionate share of the agentic economy.

The opportunity is clear:

• AI agents are actively spending money today
• Most businesses aren't set up to serve them
• Implementation is straightforward with the right tools
• Early movers are positioned for the next wave of growth

The question is simple: Will your business be discoverable when an agent searches for your service? Will you be able to accept payment when it wants to buy?

If the answer is no, you're leaving money on the table.

If the answer is yes, you're positioned to win in the next era of internet commerce.

Resources:

• Official MPP Documentation: https://mpp.dev/
• MPP Specification: https://datatracker.ietf.org/doc/draft-ryan-httpauth-payment/
• Stripe Machine Payments: https://docs.stripe.com/payments/machine/mpp
• Schema.org Service Markup: https://schema.org/Service

I mean that literally. There's no other file that touches every session, survives every compaction, and accumulates value over months of use. Your `package.json` doesn't. Your README doesn't. Your tests don't. `CLAUDE.md` does.

And yet most teams I've worked with treat it as a write-once afterthought. They generated it with `claude /init` six months ago, never opened it again, and now wonder why their agents keep making the same five mistakes.

This post is the full architecture of `CLAUDE.md` as we run it at Chipp. Root file, hub-and-spoke directory loading, scar-tissue practice, auto-load tables, sub-agent definitions, and the specific anti-patterns that turn a useful `CLAUDE.md` into a useless one.

If you only have time to internalize one thing from the autonomous development series, make it this one.

What `CLAUDE.md` actually is

`CLAUDE.md` is a markdown file in your project root. Claude Code finds it automatically and prepends its contents to the system prompt of every session in that project.

That's the whole mechanism. There's no magic. There's no plugin. The file is just *there*, and Claude reads it.

Three properties make it special.

Property 1: It loads in every session. Whether you start an interactive session, run `claude -p` headless, spawn a sub-agent, or dispatch a session from a webhook, `CLAUDE.md` is part of the system prompt every time. There is no opt-out.

Property 2: It survives compaction. When the context window fills and the model summarizes everything else, `CLAUDE.md` is one of the few things that stays intact. The post-compaction agent has lost the file contents you read, the grep results you ran, the reasoning that led to the current state, but it still has `CLAUDE.md`. (Why compaction matters →)

Property 3: It's the only training data you fully own. The model is trained on the public internet. The MCP servers you use are someone else's tools. The Claude Code CLI is Anthropic's product. `CLAUDE.md` is *yours*. It's the one piece of context the agent loads that nobody else can see, replicate, or take away.

These three properties make `CLAUDE.md` the *highest-leverage file in your codebase*. Every line in it pays compounding dividends. Every line you neglect to add costs you the same mistake, repeated, every time the agent runs.

The scar-tissue practice

The fundamental discipline of `CLAUDE.md` is treating it as a *scar tissue document*, not an aspiration document.

An aspiration document says things you wish were true. *"Always write clean code." "Prefer composition over inheritance." "Use semantic HTML."* The agent ignores most of it because the rules are too vague to act on and too unmotivated to take seriously.

A scar tissue document says things that have actually bitten you. *"Don't use lodash; we removed it in v4 and the bundle size went up 30KB last time someone re-added it." "Database migrations have to be backward-compatible because we deploy without taking the API down." "The `useUser` hook returns null during the auth bootstrap; check for it."*

Each of those sentences is a real bug we hit. Each one is a rule we wrote into `CLAUDE.md` after the third or fourth occurrence. Each one prevents the agent from making the same mistake again. The aspiration version of those rules would have been ignored. The scar tissue version is treated as load-bearing.

The mechanic for building scar tissue:

1. The agent makes a mistake. Notice it.
2. Don't fix it yet. First, prompt the agent: *"Add a rule to `CLAUDE.md` that prevents this exact mistake. Cite the failure mode you just hit. Make the rule specific enough to act on."*
3. Let the agent write the rule. The model knows what kind of rule will register on its own future inference better than you do.
4. Read the rule. Tighten it if needed. Commit it.
5. Now fix the original mistake.

After six months of doing this, your `CLAUDE.md` is a textbook of your codebase's hidden rules. Your agents stop making the mistakes you've already paid for.

"I have my autonomous AI cluster updating its own `CLAUDE.md`. I honestly barely know what's in there these days." -- Hunter Hodnett, Chipp CTPO

The three-strikes-then-rule heuristic

Don't add a rule for every mistake. If you do, your `CLAUDE.md` becomes 5,000 lines of one-off lessons and the truly important rules get diluted.

The heuristic we use: wait for the same class of mistake to happen *three times* before promoting it to a `CLAUDE.md` rule.

Once is an outlier. Twice is suspicious. Three times is a pattern. Patterns are what `CLAUDE.md` is for.

There are exceptions. If a single mistake costs real money, real customer trust, or real production downtime, it goes in the file the first time. But for the everyday small mistakes, the agent typed `useState` when it should have used our custom `useStableState`, the agent imported from `@/components/old/Button` when the new one is at `@/components/Button`, wait for the third strike.

This heuristic also keeps the file *legible*. A 200-line `CLAUDE.md` of hard-won rules is more useful than a 5,000-line `CLAUDE.md` of every observation. The agent reads the entire file every session. Make every line earn its place.

Hub-and-spoke: directory-scoped CLAUDE.md

Your root `CLAUDE.md` should not contain rules that only apply to part of your codebase.

If a rule applies only to your billing system, it shouldn't load when the agent is editing your CSS. Loading it anyway costs context budget the agent could be using to think.

The fix is a feature most people don't know exists: Claude Code automatically loads any `CLAUDE.md` it finds in or above the directory of any file it reads.

That means you can put a `CLAUDE.md` at any level of your file tree, and it will load *only* when the agent is working in that area:

• `src/db/CLAUDE.md`, loads when the agent reads any file in `src/db/`
• `src/api/auth/CLAUDE.md`, loads when the agent is in the auth subsystem
• `src/components/CLAUDE.md`, loads when the agent is in any component

We have something like fifteen `CLAUDE.md` files sprinkled throughout the Chipp codebase. Each one is small, usually 20-80 lines, and *very* specific to its directory.

The result is that the agent always has *exactly* the context it needs and very little it doesn't. Hub-and-spoke is the difference between an agent that runs out of context budget on every task and one that finishes with 70% to spare.

A practical layout looks like:

.
├── CLAUDE.md                          # root: tech stack, conventions, top-level rules
├── src
│   ├── api
│   │   ├── CLAUDE.md                  # API conventions, error handling, route patterns
│   │   ├── auth
│   │   │   └── CLAUDE.md              # auth-specific gotchas
│   │   └── billing
│   │       └── CLAUDE.md              # billing invariants, Stripe quirks
│   ├── db
│   │   └── CLAUDE.md                  # ORM rules, migration patterns, schema gotchas
│   ├── components
│   │   └── CLAUDE.md                  # design system rules, prop conventions
│   └── services
│       └── CLAUDE.md                  # service layer conventions
└── tests
    └── CLAUDE.md                      # test framework, fixture patterns

Each subdirectory `CLAUDE.md` should answer the question *"What would I tell a senior engineer who's never worked in this directory before, on day one?"*, and nothing more. If a rule is universal, push it up to the root. If it's universal *within a subdirectory*, push it down. Hub-and-spoke is a structure for keeping rules at the right level.

The auto-load table

Hub-and-spoke handles location-based context. But sometimes you want context to load based on *what the agent is doing*, not *where in the codebase it is*.

For example: if a ticket mentions "billing," the agent should load our billing playbook before it starts work, even if it doesn't yet know which files it's going to touch. Static `CLAUDE.md` placement can't handle that, because the relevant docs aren't *in* a billing directory; they're in `/docs/billing.md`.

We solve this with an auto-load table. At the top of our root `CLAUDE.md`, we have a small markdown table:

## Auto-load table

| Mention | Read |
|---|---|
| billing, stripe, payment, subscription | docs/billing.md |
| auth, login, session, oauth | docs/auth.md |
| websocket, realtime, streaming | docs/realtime.md |
| voice, livekit, transfer | docs/voice-agents.md |
| migration, schema, kysely | docs/db-migrations.md |
| feature flag, rollout, kill switch | docs/feature-flags.md |

The pattern: when a prompt mentions any of these keywords, the agent reads the corresponding doc into context before starting work.

We don't load the docs in `CLAUDE.md` itself, that would burn the budget on every session, even sessions that don't need them. We load them dynamically, only when relevant.

This is how I keep my root `CLAUDE.md` lean (around 25k tokens) while still giving the agent rich context for any specific subsystem (5k-15k of additional context, only when needed).

The auto-load table is the part of the architecture that keeps the system *learning*. Every time a successful autonomous run produces a useful insight about a subsystem, that insight goes into a markdown file in `/docs/`, and a row in the auto-load table makes it available for future runs that touch the same area.

Sub-agent definitions

Your `CLAUDE.md` should also define your sub-agents.

A sub-agent is a separate Claude Code session your main agent can spawn to do bounded work in its own context window. They live in `.claude/agents/` as their own markdown files, and your root `CLAUDE.md` should reference them.

Our root `CLAUDE.md` has a section like:

## Sub-agents

When the work calls for a deep investigation that would otherwise burn the
main context window, dispatch one of these sub-agents instead:

- `infra-ops` - for Kubernetes, deploys, networking, log investigation.
  Has the runbooks. Has the kubectl tools. Returns one-paragraph summaries.
- `feature-deep-dive` - for understanding how an existing feature works
  before modifying it. Returns an architecture summary.
- `feature-dependency-mapper` - for refactor planning. Returns the call
  graph and files affected.
- `db-investigator` - for debugging data issues. Has read access to the
  production database with safe-column allowlisting. Returns the
  smoking-gun query results.

When in doubt, prefer a sub-agent over filling the main context. The main
context belongs to the work, not the investigation.

The agent reads this in every session and knows when to dispatch what. We rely on it heavily, most of our autonomous tickets dispatch at least one sub-agent in the research phase.

Anti-patterns that wreck a `CLAUDE.md`

Six failure modes I've seen on real teams. Avoid them.

The aspiration document

Rules like *"Always write clean code"* and *"Prefer composition over inheritance"*. These are too vague to act on. The agent acknowledges them and ignores them. Replace with specific scar-tissue rules.

The bloat

A 5,000-line `CLAUDE.md` that includes everything anyone ever thought was important. Every session pays for the bloat in context budget. The truly important rules get diluted into noise. Apply three-strikes-then-rule. Push directory-specific stuff into hub-and-spoke files.

The freeze

A `CLAUDE.md` that hasn't been edited in three months. Either your codebase has stopped evolving (it hasn't) or your agent is making the same mistakes over and over and you're not bothering to write them down. The latter is the diagnosis 95% of the time.

The wishlist

Rules describing what you *wish* the codebase were like, not what it actually is. The agent reads these, dutifully writes code that matches the wish, and breaks the codebase. Document the codebase as it exists. Migrate the codebase first, then update the rule.

The TODO ledger

`CLAUDE.md` used as a personal scratch pad: *"TODO: refactor the user service. NOTE: ask Hunter about the billing thing."* This pollutes the system prompt with irrelevant content. Use a tasks file or your issue tracker for this. `CLAUDE.md` is for rules.

The single source

Trying to put everything in one file at the root. The hub-and-spoke pattern exists precisely because not everything belongs in the root. If your root `CLAUDE.md` is over 1,000 lines, you're failing to use the directory mechanism.

How to start one if you don't have one

For a fresh project: run `claude /init` to generate a starter file. Then immediately delete most of what it generates. The generated `CLAUDE.md` is too generic to be useful, it's a placeholder for the scar tissue you'll write yourself.

Replace the boilerplate with three things:

1. Your tech stack. One-line summary of what you're using. *"Deno + Hono on the server, Svelte 5 on the client, Cloudflare Workers for delivery."*
2. The two or three most important rules. Things you already know will trip the agent up. *"We use Kysely, not Prisma. Migrations are expand-then-contract; never both at once."*
3. An empty auto-load table. Just the header. You'll fill it in as you generate `/docs/` files.

That's the whole starter. Resist the urge to write more. The remaining content has to be earned through actual scar tissue.

How to fix one that's a mess

If you have a `CLAUDE.md` that's already 3,000 lines of garbage, the cleanup pattern is:

1. Audit for the three-strikes-then-rule violation. Any rule that hasn't paid for itself by preventing a real bug? Cut it.
2. Push location-specific rules into hub-and-spoke. A rule about your auth system goes in `src/api/auth/CLAUDE.md`. A rule about your CSS goes in `src/components/CLAUDE.md`. The root file should only have rules that apply everywhere.
3. Convert aspirations to scar tissue. *"Always validate input"* becomes *"Use the `assertValidUuid()` helper before any DB query against an id column. We've shipped four 500s from this exact mistake."*
4. Build the auto-load table. Group related rules into `/docs/` files. Reference them in the auto-load table. Cut them from the root file.

This audit is itself a great task to hand to an agent. Open an interactive session, share the current `CLAUDE.md`, and ask the agent to apply the audit pattern. It'll do most of the work for you.

The compounding asset

The reason `CLAUDE.md` matters more than any other file in your codebase is that it's the only artifact whose value compounds with every successful autonomous run.

Every line of code you write decays, frameworks change, requirements shift, tests need updating. Every line in `CLAUDE.md` becomes more valuable, because it's preventing a class of mistake across all future sessions.

After three years of running this discipline, your `CLAUDE.md` is the most important asset in your codebase, more valuable than any individual feature you've shipped, because it's the thing that lets you ship the *next* feature reliably.

Treat it accordingly. Read it monthly. Edit it weekly. Audit it quarterly. The teams who run autonomous development at scale all have this in common: they take their `CLAUDE.md` seriously.

The teams that don't end up wondering why their agents are still making mistakes after six months. They are. The mistakes are documented in your bug tracker. They aren't documented in `CLAUDE.md`. That's the gap.

[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)

If you want the full discipline of context engineering, read Context Engineering: The Skill That Turns Claude Into a Production Co-Developer.

If you want to see how `CLAUDE.md` fits into a real autonomous pipeline, read Building a Self-Healing Bug Bot.

If you want to know when to use a skill versus a sub-agent (the next layer up from `CLAUDE.md`), read Skills vs Sub-Agents.

I learned about it the next morning. The error had landed in our log drain at 3:31. The fix had shipped at 3:47. Sixteen minutes from production fire to production deploy.

I was asleep through all of it.

This post is how to build the system that lets you sleep.

What Bug Bot is

Bug Bot is the autonomous development cluster that runs Chipp. It picks up production bugs and feature tickets from four trigger sources, runs each through a five-stage pipeline, and pushes verified code to production without human review. Eight workers run in parallel on a single workstation. We ship 20-30 production changes per day. There are no pull requests in this system.

The high-level case for it is in The Autonomous Development Manifesto. This post is the implementation. If you've been wondering whether you could build one of these for your own product, the answer is yes, and what follows is enough to start.

The architecture

   ┌───────────────────────────────────────────────────────┐
   │                   TRIGGER LAYER                        │
   │   Slack       Email       Grafana      P95 Latency    │
   │    tag       forward      webhook         alert       │
   └─────┬──────────┬───────────┬───────────────┬──────────┘
         │          │           │               │
         └──────────┴────┬──────┴───────────────┘
                         ▼
                  ┌──────────────┐
                  │ TICKET QUEUE │
                  └──────┬───────┘
                         ▼
            ┌──────────────────────────┐
            │   BASH HARNESS POOL       │
            │   (8 workers, max)        │
            └────┬─────┬─────┬─────┬───┘
                 │     │     │     │
                 ▼     ▼     ▼     ▼
            ┌────────────────────────┐
            │  CLAUDE CODE PIPELINE  │
            │                        │
            │ Phase 0: Doc retrieval │
            │ Phase 1: Research      │
            │ Phase 2: Implement     │
            │ Phase 3: Review        │
            │ Phase 4: Docs update   │
            │ Phase 5: Push          │
            └─────────┬──────────────┘
                      ▼
                  [PRODUCTION]
                      │
                      ▼
        (errors loop back via trigger layer)

Five components. Each one is replaceable; what matters is that they all exist and they all integrate.

Component 1: The trigger layer

Tickets need to land in your queue. We use four sources.

Loki + Grafana for production errors

Self-hosted log aggregation. Every server-side error is logged to Loki via a structured log call:

log.error({
  service: 'billing',
  feature: 'create_customer',
  err: error.stack,
  user_id: hashUserId(userId),
});

Sensitive fields are one-way encrypted before they ever land in logs. The agent gets metadata, not secrets.

A Grafana alert rule fires every five minutes:

WHEN errors_count_5m > 5
  AND grouped_by_stack_trace
THEN webhook(POST /bug-bot/trigger)

The five-minute window dedupes, if 47 instances of the same error happen, the agent gets one ticket, not 47.

Webhook server

A small Hono server listens for Grafana webhooks. Its only job is to construct a Bug Bot prompt and add it to the queue:

app.post('/bug-bot/trigger', async (c) => {
  const alert = await c.req.json();
  const prompt = `
Production error detected.

Service: ${alert.labels.service}
First seen: ${alert.firstSeen}
Affected users: ${alert.uniqueUsers}
Stack trace:
${alert.stackTrace}

Investigate and fix. The auto-load table will pull relevant docs.
`;
  await ticketQueue.add({ source: 'grafana', prompt });
  return c.json({ ok: true });
});

Slack tag

A Slack listener watches our internal `#chipp-rewrite-bugs` channel for `@bug bot` mentions. The thread becomes the prompt:

slack.event('app_mention', async ({ event }) => {
  const thread = await slack.getThread(event.thread_ts);
  await ticketQueue.add({
    source: 'slack',
    prompt: thread.messages.map(m => `${m.user}: ${m.text}`).join('\n'),
  });
});

Email forward

I forward customer emails to a Bug Bot inbox. A Mailgun webhook converts each email into a ticket. (I dictate most of mine via Whisper Flow on my phone, yes, I voice-message my engineering team.)

P95 latency alert

A separate Grafana alert rule fires if our chat-streaming P95 exceeds three seconds. Different prompt template, same queue.

The shape of the trigger layer matters less than the principle: tickets should land in your queue from anywhere a human or system might notice a problem.

Component 2: The bash harness

This is the most important component. The bash harness is what turns Claude, non-deterministic, prone to running long, occasionally trying to `git push --no-verify` its way out of a problem, into a deterministic teammate.

"An autonomous agent without a bash harness is an intern with no manager, no deadline, and an unlimited API budget." -- Hunter Hodnett, Chipp CTPO

The harness is shell script, not Node or Python. We've considered both. Bash wins because Claude is also writing the harness, and Claude has more bash training data than any other shell language. The harness needs to be readable, debuggable, and easily edited by the same agent it manages.

Skeleton

#!/usr/bin/env bash
set -euo pipefail

WORKER_ID=$1
TICKET_FILE=$2
WORKTREE_DIR="/tmp/bug-bot/worker-${WORKER_ID}"
DEV_PORT=$((5180 + WORKER_ID))
IDLE_TIMEOUT=300  # 5 minutes
BANNED_FLAGS="git push --no-verify|git reset --hard|rm -rf /"

# Set up worktree
git worktree add -b "bot/${WORKER_ID}-$(date +%s)" "$WORKTREE_DIR" main
cd "$WORKTREE_DIR"

# Spawn dev server in background on dedicated port
PORT=$DEV_PORT pnpm dev > "/tmp/bug-bot/worker-${WORKER_ID}.log" 2>&1 &
DEV_PID=$!

# Run the 5-stage pipeline
for STAGE in research implement review docs push; do
  PROMPT_FILE="prompts/${STAGE}.md"

  # Spawn Claude in headless mode
  timeout $IDLE_TIMEOUT claude -p \
    --dangerously-skip-permissions \
    --append-system-prompt "$(cat $PROMPT_FILE)" \
    < "$TICKET_FILE" 2>&1 | tee "stage-${STAGE}.log" &
  CLAUDE_PID=$!

  # Banned-flag watch
  while kill -0 $CLAUDE_PID 2>/dev/null; do
    if grep -qE "$BANNED_FLAGS" "stage-${STAGE}.log"; then
      echo "BANNED FLAG DETECTED - killing worker $WORKER_ID"
      kill $CLAUDE_PID
      exit 1
    fi
    sleep 2
  done

  wait $CLAUDE_PID
done

# Force final commit + push if not already done
if ! git diff --cached --quiet; then
  git add -A
  git commit -m "[bug-bot/${WORKER_ID}] $(cat ticket-summary.txt)"
fi
git push origin HEAD:staging

# Cleanup
kill $DEV_PID
git worktree remove "$WORKTREE_DIR" --force

# Log outcome for fine-tuning
echo "{\"worker\": ${WORKER_ID}, \"ticket\": \"$(basename $TICKET_FILE)\", \"outcome\": \"clean\"}" \
  >> /var/log/bug-bot/outcomes.jsonl

This is simplified. Our production version has more error handling and outcome labeling. The shape is right.

What the harness enforces that Claude can't

• Idle kill. If Claude doesn't fire a tool call for five minutes, the session is killed. This catches the case where Claude gets stuck in a "let me think about this" loop.
• Banned-flag grep. If Claude attempts `git push --no-verify`, `git reset --hard`, or `rm -rf` against an absolute path, the session is aborted.
• Forced commit + push. Claude occasionally completes work but forgets the final push. The harness checks the worktree state and forces it.
• Worktree cleanup. Each run is isolated; nothing leaks between workers.
• Port allocation. Each worker gets a dedicated dev server port (5180 + worker ID).
• Outcome logging. Every run writes a JSONL row to a fine-tuning archive. (More on this below.)

Component 3: The five-stage Claude pipeline

Each stage is its own Claude Code session, with its own context window. The stages communicate via files written to disk.

Phase 0: Doc retrieval (bash, not Claude)

Before any Claude session runs, a bash script semantic-searches `/docs/` for files relevant to the ticket and writes the results to `pre-context.md`:

docs-search "$(cat ticket.txt)" > pre-context.md

`docs-search` is a small CLI we wrote that runs OpenAI's embeddings API over our `/docs/` folder once per week and stores vectors in a local SQLite file. Could be any vector store. The point is to load relevant context before Claude opens its first context window.

Phase 1: Research

You are the research agent for an autonomous dev pipeline.

Read the ticket. Read pre-context.md. Read relevant code.
Query Loki for similar errors. Query the database if useful.
Form a hypothesis.

Output a plan.md with:
- Root cause
- Affected files
- Implementation steps
- Test strategy
- Risks

DO NOT edit any source files in this phase.

Output: `plan.md`. Context window can fill up to 1M tokens of investigation; only the plan survives.

Phase 2: Implement

You are the implement agent.

Read plan.md. Read pre-context.md. That's your context.
Make the code changes described in plan.md.
Run unit tests for affected files.
Run the full test suite.
Spin up dev server on port ${DEV_PORT}.
Open browser MCP. Navigate to affected URLs.
Read browser console + dev server logs.
Fix anything broken.

Commit your changes when verified.

Fresh context window. The agent never sees the original investigation, only the distilled plan.

Phase 3: Review

You are the review agent.

Read the diff. Red-team it.
Look for: edge cases, security issues, type errors, broken contracts.
You can edit. If you make more than 5 edits, the implement agent's work is flagged messy.

Output: approved | needs-rework, plus reasoning.

Phase 4: Docs update

You are the docs agent.

Given the diff, identify any non-obvious behavior introduced.
Write or update markdown files in /docs/ to capture it.
Identify any docs the change has invalidated. Prune them.
Update the auto-load table at the top of CLAUDE.md if needed.

This is how the system gets smarter over time.

Phase 5: Push

Bash, not Claude. Final commit, push to staging branch, monitor deploy.

Component 4: The MCP fleet

Without MCP, your agent can read code and reason. With MCP, it can verify, query, and act. The four MCPs every Bug Bot setup needs:

Browser MCP (custom, dev-tools protocol)

This is the single most important MCP in autonomous development. Without it, you're guessing.

Our browser MCP wraps a local Chromium instance via the dev-tools protocol. It exposes:

• `browser_navigate(url)`, go to a page
• `browser_screenshot()`, return a base64 image
• `browser_console_logs()`, return recent console messages
• `browser_click(selector)`, interact with the page
• `browser_dev_login(role)`, bypass our auth flow with seeded test credentials

That last tool is the differentiator. Off-the-shelf browser MCPs are generic. The MCP we run for Chipp knows how to log in as a free user, an enterprise user, or a paying user with exhausted credits, without going through the human OAuth flow. That domain knowledge is what makes verification fast.

Log-drain MCP (custom)

Wraps Loki. Exposes:

• `loki_query(labels, time_range)`, run a LogQL query
• `loki_user_breadcrumbs(user_id, time_range)`, pull a user's recent interactions before the error fired

The user breadcrumbs tool is what lets the agent reconstruct the user journey that led to a bug, and propose fixes that match real usage, not synthetic edge cases.

Database MCP (custom)

Wraps our database with hard-coded safe column lists. We give the autonomous agents read access to production. The MCP enforces:

• No `SELECT *`. The MCP returns only the columns you've explicitly allowed.
• Sensitive columns (passwords, OAuth tokens, payment methods) are filtered out at the MCP layer; the agent never sees them in any session.
• All queries are read-only by default. We have a write-enabled variant gated behind an additional bash-harness check.

We tried off-the-shelf database MCPs first. They hallucinated column names constantly. Custom won.

File system + bash (built-in)

Claude Code includes file system and bash tools by default. You don't need to install these. You do need to ensure your `CLAUDE.md` documents which paths are off-limits and which commands are dangerous.

Component 5: The verification loop

The browser MCP is the loop. Here's the actual sequence each implement agent runs after writing code:

1. Code changes saved in worktree.
2. Worktree's dev server (already running on dedicated port) auto-reloads.
3. Agent calls `browser_navigate('localhost:5184/affected-page')`.
4. Agent calls `browser_screenshot()`. Reads the image.
5. Agent calls `browser_console_logs()`. Reads the console output.
6. If no errors, the agent calls `browser_click('#confirm')` to interact with the changed UI.
7. Repeat screenshot + logs read.
8. If errors detected, the agent forms a hypothesis, edits the code, and the loop starts over.

The loop is what separates autonomous development from vibe coding. Vibe coding ends with the diff. Autonomous development ends with verified production code.

"Claude writing code without verification is a liability. Claude writing code and verifying and pushing to prod is a teammate with commit access." -- Hunter Hodnett, Chipp CTPO

Outcome logging for fine-tuning

Every Bug Bot run writes a JSONL row to a long-term archive:

{
  "ticket_id": "billing-create-customer-null-pmt",
  "trigger_source": "grafana",
  "started": "2026-04-15T03:31:18Z",
  "finished": "2026-04-15T03:47:02Z",
  "stages": {
    "research": { "tokens": 412053, "tool_calls": 38 },
    "implement": { "tokens": 187234, "tool_calls": 23 },
    "review": { "tokens": 91482, "tool_calls": 12, "edits": 1 },
    "docs": { "tokens": 43210, "tool_calls": 4 },
    "push": { "tokens": 0, "tool_calls": 0 }
  },
  "outcome": "clean",
  "regressions_detected_24h": false
}

The `outcome` field is the label. `clean` means: review made ≤5 edits, all tests passed first try, no regressions detected within 24 hours of deploy. `messy` means anything else.

This data is gold. Every successful autonomous run produces a labeled training row showing how a frontier model approached a real engineering task. Builders who treat their pipeline outputs as a strategic data asset, instead of throwing them away after each run, end up with the training data to fine-tune cheaper specialized models on their own codebase. That's a moat. We'll cover the mechanics of it in a future post.

The cost reality

Bug Bot is not free. Each ticket runs through five Claude Code sessions, each with substantial context. Order of magnitude: low double-digit dollars per ticket on a frontier model, at current pricing.

That sounds expensive until you compare it to the alternative. A single Bug Bot ticket replaces approximately a junior engineer's day of work, read the stack trace, find the bad commit, write the fix, test it, ship it. The cluster runs all day, all night, with no benefits package.

We get roughly a 10-50x cost advantage versus traditional engineering labor for the kind of work Bug Bot does best (fixing bugs in well-documented code paths, building features within an established architecture). For more open-ended work, designing new systems, debugging hardware integrations, reasoning about edge cases that aren't represented in our training data, the cost advantage compresses, sometimes to break-even.

The honest truth: Bug Bot succeeds on first try about 70-80% of the time. The other 20-30% require a re-prompt, often because we didn't include enough context the first time. We treat those failures as scar tissue. Almost every re-prompt becomes a doc, a `CLAUDE.md` rule, or an auto-load table entry that prevents the same failure next time.

When this fails (and how we fix it)

Failure modes worth knowing about before you start:

Cross-tool integrations

Anything outside your code base is high risk. Bug Bot is great at fixing bugs in our own code. It's worse at debugging issues with a Stripe API change, a LiveKit voice agent update, or any third-party service whose behavior the agent can't directly observe.

The fix is custom MCPs. We built a Stripe MCP that wraps Stripe's API in tools the agent can call directly. Same for LiveKit. The pattern: any external dependency that breaks Bug Bot's success rate gets its own MCP server.

Decomposition failures

Bug Bot is designed for tasks that fit in one pipeline run. *"Fix this billing bug"* works. *"Build a new analytics dashboard with 12 widgets"* doesn't.

The bottleneck isn't execution. It's decomposition. Large features need a human (or another autonomous layer) to break them into pipeline-sized tickets. We handle this manually for now. The next iteration of Bug Bot will include a decomposition stage that runs before the research stage.

"Hard part is decomposition, not execution." -- Hunter Hodnett, Chipp CTPO

MCP server downtime

If your browser MCP or database MCP goes down, your agents lose their senses mid-session. We treat MCP servers as production infrastructure: monitored, alerted, deployed in pairs.

Banned-flag false positives

Occasionally the harness kills a session for what looks like a banned flag in a comment or test fixture. We've tightened the regex over time. When in doubt, log the false positive and investigate; don't relax the regex pre-emptively.

What this gives you

The 3:47 AM moment becomes routine.

The on-call rotation goes empty. PagerDuty escalations stop. Senior engineers stop reviewing AI-generated PRs because there are no PRs. The PR queue empties because there's no concept of a PR in this system. Customer-reported bugs get fixed before the customer support team has finished writing the ticket.

You sleep through the night. You wake up to a Slack channel full of completed work. You spend your day on decomposition, judgment, and the kinds of architectural decisions only a human can make, because every other thing has been done by the cluster.

That is what Bug Bot gives you. It's also what we're productizing as Alchemist for builders who'd rather not spend nine months building it themselves.

[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)

If you want the foundational case for autonomous development, start with The Autonomous Development Manifesto.

If you want to understand the discipline that makes this all work, the foundation underneath the harness, the pipeline, and the MCPs, read Context Engineering: The Skill That Turns Claude Into a Production Co-Developer.

Everything you've ever read about getting the most out of an AI agent, every tip about prompts, every technique for "making Claude smarter", collapses into managing what fits on that paper.

This is context engineering. It's not a mindset. It's not a philosophy. It's a set of mechanical decisions about what tokens go into the context window, what tokens get compressed, and what tokens never make it in at all.

Get it right and your agent finishes its work, ships, and moves on. Get it wrong and your agent enters a doom loop of re-reading the same files, summarizing its own findings, hallucinating results, and asking you for context it should have inferred.

In our autonomous development cluster at Chipp, context engineering is the difference between an agent that ships 25 production changes a day and one that fills a context window with 90 tool calls of confusion before timing out. We've made the mistakes. This post is the rules I wish I'd known a year ago.

What's actually in your context window

Every Claude Code session has six things competing for the same paper:

1. The system prompt. Your `CLAUDE.md`, plus any subdirectory `CLAUDE.md`s loaded by the hub-and-spoke pattern.
2. The tool definitions. Every MCP server adds its tool schemas. The descriptions are part of every prompt.
3. The conversation history. Every prior user message, assistant message, and tool call result since the session started.
4. The tool results. File contents you read. Grep results. Database query rows. Browser screenshots. All of these get serialized into context.
5. The reasoning scratch space. Where the model thinks. Internal chain-of-thought tokens that don't show up in the final output.
6. The current user message and the pending response.

You don't get to choose how the model allocates between these. You get to choose what's available to fill them.

A typical Claude Sonnet/Opus session has 1M tokens of context. Your `CLAUDE.md` should fit in under 25k of that, about 5% of the budget. Tool definitions for a typical autonomous setup will run another 20-50k. That leaves roughly 900k for actual work.

The math sounds generous until you read three files of 1,500 lines each, run a few grep commands, and take two browser screenshots. You're 200k tokens into your remaining budget before the agent has done anything productive.

The compaction trap

When the context window fills, the model doesn't gracefully degrade. It hits compaction: a smaller, cheaper model summarizes the entire conversation into a paragraph and replaces the original tokens. The session continues, but the model wakes up with vague recollections instead of specifics.

What you lose in a compaction:

• The exact file contents you read.
• The specific stack traces and error messages from earlier in the session.
• The reasoning chain that led to the current state.
• Specific line numbers, variable names, and database row values.

What survives:

• The system prompt (your `CLAUDE.md`).
• A paragraph summary of everything that was compacted.
• The most recent few messages.

A summary written by a cheap model is a worse representation of the past than the actual past. After a compaction, the agent is reasoning over a faded photocopy of its memory. This is where hallucinations come from.

"Compaction is incredibly destructive. You really want to avoid compactions at all cost." -- Hunter Hodnett, Chipp CTPO

The corollary: your `CLAUDE.md` is your highest-leverage file. It survives compactions. Everything else is in danger.

The four core moves

Context engineering, in practice, is four moves you make over and over. None of them are hard. The discipline is doing them consistently.

Move 1: Stabilize the system prompt for KV-cache hits

Anthropic's API caches input tokens. If your system prompt is byte-identical between two requests, the cached version costs you a fraction of the original.

This sounds obvious until you realize how easy it is to bust the cache by accident. We were burning through input tokens at full price for months before we figured out our bug.

Our `CLAUDE.md` had a line that injected the current date so the agent would know what day it was. We were injecting the date down to the second:

The current date and time is: 2026-05-06T14:23:47.318Z

That value changed on every request. The cache busted on every request. We were paying full price for a 25k-token system prompt thousands of times a day.

The fix was trivial:

The current date is: 2026-05-06

KV cache hits jumped from near-zero to over 90%. Token spend dropped accordingly.

The general rule: anything in your system prompt that varies between calls, timestamps, request IDs, randomly-ordered lists, busts the cache. Make the system prompt stable. Inject volatile context as user messages, not as system prompt content.

Move 2: One context window per goal

The single biggest mistake teams make is trying to do too much in one session.

You start a Claude Code session. You ask it to investigate a bug. It reads ten files, runs a few grep commands, queries the database. It forms a hypothesis. You ask it to implement the fix. It writes the code, runs the tests. You ask it to review the code. It edits a few things. You ask it to update the docs. By now you're six tool calls past compaction and the agent's reasoning has gone fuzzy.

The fix: break the work into stages, and start a fresh context window for each stage.

This is what our Bug Bot pipeline does. Five stages, research, implement, review, docs, push, and each stage is a separate session. The output of one stage is a markdown file, which becomes the input for the next.

Stage 1 fills its context window with research and outputs a `plan.md`. Stage 2 starts fresh, reads only `plan.md`, writes the code. Stage 3 starts fresh, reads only the diff, reviews it.

No stage ever runs out of room because no stage tries to do everything.

Move 3: Use sub-agents to dilute

Some work is inherently context-heavy. Investigating a Kubernetes pod restart can require reading thousands of lines of logs, querying multiple endpoints, cross-referencing deploy histories. If you do this in your main session, you've burned your budget.

The solution: spawn a sub-agent. The main session calls the sub-agent like any tool, the sub-agent gets its own fresh 1M-token context window, it does whatever investigation it needs, and it returns a one-paragraph insight.

The first time we used this in production was for an infrastructure issue. Pods were restarting; we didn't know why. I prompted the main session: *"Figure out why our pods are restarting."* It spawned an `infra-ops` sub-agent we'd configured with all our Kubernetes runbooks.

The sub-agent ran 47 `kubectl` commands. Queried Loki for recent error patterns. Cross-referenced the deploy history. Filled almost a full context window with raw evidence.

Then it returned one sentence: *"OOM after the last deploy, memory limit too low; recommend bumping the limit from 512Mi to 1Gi."*

That sentence, 23 tokens, was what landed in my main session. The 950k tokens of evidence stayed in the sub-agent's context, where it belonged.

Use sub-agents for any work where the answer is short but the investigation is long.

Move 4: Pre-load with an auto-load table

Hub-and-spoke `CLAUDE.md` works for static, location-based context. But sometimes you want context to load based on *what the agent is doing*, not *where in the codebase it is*.

We built an auto-load table for this. At the top of our root `CLAUDE.md`, we have a small markdown table:

## Auto-load table
| Mention | Read |
|---|---|
| billing, stripe, payment, subscription | docs/billing.md |
| auth, login, session, oauth | docs/auth.md |
| websocket, realtime, streaming | docs/realtime.md |
| voice, livekit, transfer | docs/voice-agents.md |

The pattern: when a prompt mentions any of these keywords, the agent reads the corresponding doc into context before starting work.

We don't load the docs in `CLAUDE.md` itself, that would burn the budget on every session, even sessions that don't need them. We load them dynamically, only when relevant.

This is how I keep my root `CLAUDE.md` lean while still giving the agent rich context for specific subsystems.

"I have my autonomous AI cluster updating its own `CLAUDE.md`. I honestly barely know what's in there these days." -- Hunter Hodnett, Chipp CTPO

The mental model

Picture the context window as a single sheet of paper, fixed font size.

When you read a file, you've copied that file onto the paper. When you run a grep, you've copied the result. When the agent reasons, it's writing on the paper.

Run out of room and the paper gets folded. A cheap intern reads everything you wrote and replaces it with a paragraph summary on a fresh sheet. You keep working but you've lost the details.

The discipline of context engineering is engineering what gets written on the paper before it runs out, and never letting the cheap intern get involved.

Patterns we use every day

Beyond the four core moves, here are the patterns that show up most in our daily work.

Fresh-context handoff via markdown

Pipeline stages communicate by writing markdown files to disk. Stage 1's last action is `Write plan.md`. Stage 2's first action is `Read plan.md`. Stage 1's context window is gone forever, but the distilled insight survives.

This is the same pattern as the sub-agent dilution move, applied to sequential work.

Three-strikes-then-rule for `CLAUDE.md`

Don't add a rule to `CLAUDE.md` after a single mistake. Wait for the same class of mistake to happen three times. Otherwise your `CLAUDE.md` bloats with one-off lessons that never recur, and the truly important rules get diluted.

Three strikes is a heuristic, not a hard rule. The point is to be conservative about what gets the elevated status of "every-session context."

Hub-and-spoke directory loading

Place a `CLAUDE.md` in any subdirectory where the rules differ from the root. Claude Code automatically reads the nearest `CLAUDE.md` when it reads a file in that directory.

We have `CLAUDE.md` files in:

• `src/db/`. ORM-specific rules (we use Kysely, not Drizzle; never let the agent forget)
• `src/api/`. API conventions (Hono routing, error-handling patterns)
• `src/components/`, design system rules (CSS variables only, never hex codes)
• `tests/`, test framework conventions

The agent loads the right one without me having to tell it.

Kill the summary mid-stream

When you see Claude write something like *"I've now read several files. Let me summarize what I learned…"* in the middle of an interactive session, stop it. That summary is about to land in your context as the canonical record of what the agent did. You want the *evidence*, not a pre-compaction.

Tell it: *"Don't summarize. I want to see the actual results."*

This matters less in autonomous pipeline runs, you're not watching those, but the underlying principle is general: prefer raw artifacts over the agent's interpretation of artifacts.

Use the most powerful model: every time

When teams ask me how to save money on token spend, the first thing I say is: don't.

Use the most expensive model. Always. Even when it feels wasteful.

The reason is that frontier models hallucinate less, plan better, and finish work in fewer total tokens. A cheaper model in an autonomous setting will burn more total tokens chasing its own mistakes than a frontier model would have spent doing the work right the first time.

This is even more true in the early weeks after a model release. Frontier labs subsidize new models, they serve the highest-quality version at launch and gradually quantize them down to cheaper-to-serve versions over the following weeks. If you're going to do hard work with an autonomous agent, do it in the first weeks after a release, when the model is at its sharpest.

Write your context-engineering scars into auto-load docs

When you encounter a context-engineering failure, say, the agent kept reading the wrong file because it didn't have enough context about a subsystem, don't put the lesson in your root `CLAUDE.md`. Write a doc into `/docs/`, add a row to the auto-load table, and move on.

Auto-loaded docs are scoped to relevance. Root `CLAUDE.md` is global. Match the scope of the lesson to the scope of the file.

Capture every run's data

Every Claude Code session you run produces a record of how a frontier model reasoned about a real problem in your codebase. That's training data, the kind that, six months from now, you might want to fine-tune a cheaper specialized model on. The builders who treat their pipeline outputs as a strategic data asset, instead of throwing them away after each run, will end up with the only kind of moat that compounds in this industry.

Even if you never do anything with the data, archive it. Storage is cheap. Past inference is irreplaceable.

How you know it's working

You know context engineering is working when:

• The agent finishes work without compacting.
• Re-running similar tasks gives consistent quality.
• You can launch sessions, walk away, and come back to shipped code.
• The agent stops asking you for context it should have inferred.
• Your `CLAUDE.md` grows by a line or two per week, not per day.

You know it's not working when:

• The agent hits compaction in the middle of routine tasks.
• You see the same hallucinations repeatedly (this is your scar tissue not yet hardened into rules).
• The agent reads the same files in every session because there's no doc layer to load them once and remember.
• Token spend per task is going up, not down.

If you're in the second category: start with one core move at a time. Get the system prompt stable for KV cache hits. Then split your sessions one-context-per-goal. Then add sub-agents for any investigation that fills the budget. Auto-load tables are the polish; the moves above are the foundation.

What's next

Context engineering is the foundational discipline of autonomous development, but it's only the first layer. Layered on top of it:

• [CLAUDE.md Architecture](/blog/claude-md-architecture): the hub-and-spoke pattern, scar tissue practice, and auto-load tables in detail.
• [Skills vs Sub-Agents](/blog/skills-vs-sub-agents): when to use which, and why the distinction matters.
• [MCP Is the USB-C of AI](/blog/building-your-first-mcp-server): building the senses that let your agent verify its own work.
• [Building a Self-Healing Bug Bot](/blog/self-healing-bug-bot): context engineering applied end-to-end in a production pipeline.

If you want to see what context engineering enables in production, start with The Autonomous Development Manifesto.

If you want to see what it looks like when it goes wrong, run an interactive Claude Code session for an hour without thinking about any of this. Watch your token spend. Watch the agent compact. Watch it hallucinate. That's the baseline. Everything above is what we do to escape it.

[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)

For fifty years, software was written by humans typing code one keystroke at a time. For the last five, by humans typing code while a model whispered the next token. We told ourselves the model was an assistant, that the human was still the author.

We were wrong about how much of the job could be automated. Not just the typing. The reading. The reasoning. The verification. The shipping.

I run an engineering team of two people. We push 20 to 30 changes to production every day. The pull request queue is empty because there are no pull requests. The on-call rotation is empty because there is no on-call rotation. I have slept through the night for the last two months.

This isn't a vibe-coding demo. This isn't "AI is going to change everything someday." This is a description of the system that built and runs Chipp, the platform behind 125,000+ AI agents that have held 14M+ conversations with real users. The system we call Bug Bot. The system that, over the next year, we are productizing as Alchemist, and offering as autonomous development as a service.

This post is for the engineers who suspect this is real but haven't seen it for themselves.

It's also for the engineers who think they're better than AI. You are. For now. The window in which that's true is closing faster than most people realize.

Let me show you what's on the other side.

Part 1: What "autonomous development" actually means

The terms are getting thrown around and they're not all the same thing.

Autocomplete. A model finishes your line. You're still the author.

AI pair programmer. A model writes a function. You read it, edit it, commit it. Copilot's original pitch.

Vibe coding. A model writes most of the code. You review the diff, occasionally course-correct, ship the result. The human is still in the loop on every step.

Agentic coding. The model executes tools, runs commands, reads files, calls APIs, to accomplish a goal. The human still drives the session.

Autonomous development. The model is given a goal. It selects its own steps, executes them, verifies the results, and ships. There is no human in the loop on individual steps. There may not be a human in the loop on the *outcome* either, if you set it up that way.

The distinction that matters most: what happens when the model writes wrong code?

In vibe coding, you catch it in the diff and tell the model to try again.

In autonomous development, the model catches it itself, by spinning up a dev server, opening a browser, navigating to the changed page, taking a screenshot, reading the console logs, noticing the error, and fixing it.

That last sentence is the entire game. Everything else in this post is mechanical detail about how to get there.

"Claude writing code without verification is a liability. Claude writing code and verifying and pushing to prod is a teammate with commit access." -- Hunter Hodnett, Chipp CTPO

Part 2: The maturity curve

We're somewhere in the middle of a five-stage industry shift. Where you sit on this curve will determine whether your business compounds or capsizes over the next twenty-four months.

Stage 1. Acceleration. Faster typing. Slightly fewer keystrokes per shipped feature.

Stage 2. Augmentation. Models write the boring code. Humans write the novel code and review everything. The senior engineer still does most of the thinking.

Stage 3. Vibe coding. Models do most of the typing. Humans become editors and product designers in the loop. Output velocity 5-10x. Demos are great. Production code is hit or miss. Most builders are stuck here today.

Stage 4. Agentic coding. Models can run tools, read files, search the web, query databases, open browsers. With the right setup, they can verify their own work. The human still drives the session. Output velocity 20-50x for a session, but each session needs a human to launch and oversee.

Stage 5. Autonomous development. Models run unattended. Multiple agents in parallel. Goal-directed. Self-verifying. The human role is decomposition (turning intent into tickets) and judgment (reviewing outcomes). Output velocity is no longer the right metric, *organizational capacity* is. This is what we run. This is what Alchemist productizes.

Each stage doesn't replace the prior one. It absorbs it. Inside an autonomous development cluster, you'll find vibe-coding sessions, agentic coding loops, and AI pair programming. They're all in the box. The cluster is what wraps them in a deterministic harness.

If your team is at Stage 3 and your competitor is at Stage 5, your competitor isn't 10% faster. They're operating in a different category of business. Their feature velocity isn't bottlenecked by engineer count. Yours is.

Part 3: ADaaS (Autonomous Development as a Service)

Here's the awkward part. Most teams should not build their own autonomous development cluster from scratch.

We did, because we had to. Three years of full-time work. Dozens of mistakes, including a few production database drops along the way. An immense amount of inference burned figuring out which prompts, harnesses, and architectures actually hold up under autonomous load.

The hard parts aren't where you'd expect them. They're not in the model. The model is fine. They're in:

• The bash harness: the deterministic wrapper that prevents your non-deterministic agents from running away with your token budget.
• The verification loop: getting the agent to actually look at the running software and see what it built.
• The context engineering discipline: knowing what to load, what to prune, what to summarize, what to never compact.
• The CLAUDE.md scar-tissue practice: turning every agent mistake into a rule that prevents that mistake forever.
• The pipeline decomposition: splitting one task across multiple context windows so no single window has to hold everything.

You will spend nine months learning these the hard way. We already did. So we are productizing it.

That's what ADaaS (autonomous development as a service) means. You don't rent a tool. You don't rent a model. You rent a *process*: a configured cluster, a hardened harness, a verification loop, a maintained set of MCP servers, a documentation auto-load system, the whole apparatus that lets you point at a goal and get shipped software.

The lineage:

• SaaS productized software.
• PaaS productized application platforms.
• IaaS productized infrastructure.
• ADaaS productizes the engineering practice itself.

We coined the term because nobody else had. Don't be surprised when the rest of the industry catches up to it within a year, the underlying economic logic is too powerful to stay underground.

Part 4: Inside the autonomous dev cluster

Let me show you what's running on my desk right now.

I have eight Claude Code workers running in parallel on a single workstation. Each worker is an instance of `claude -p`. Claude Code's headless mode, wrapped in a bash script that monitors its output, kills it if it stalls, and forces a commit at the end.

Tickets enter the system through four trigger sources:

1. Slack tag. Anyone on my team can `@bug bot` in our internal channel. The mention payload becomes the prompt.
2. Email forward. I forward customer emails to a Bug Bot inbox. The email body becomes the prompt. I dictate most of mine via Whisper Flow on my phone, yes, I voice-message my engineering team.
3. Grafana webhook. Every five minutes, our log ingestion pipeline groups recent production errors by stack trace, dedupes them, and fires a webhook. The error context becomes the prompt.
4. Performance alert rule. When P95 chat-streaming latency exceeds three seconds, a worker spawns automatically.

When a ticket lands, it runs through five stages. Each stage gets its own context window. This is the most important architectural rule in the whole system.

[Trigger] → [Phase 0: Doc retrieval] → [Phase 1: Research]
         → [Phase 2: Implement]   → [Phase 3: Code review]
         → [Phase 4: Docs update] → [Phase 5: Push to prod]

Phase 0. Doc retrieval. Before Claude even sees the ticket, a bash script semantic-searches our `/docs/` folder for any markdown files relevant to the ticket. Those docs get prepended to the research prompt as context.

Phase 1. Research. Fresh context window. Claude reads relevant code, queries our log drain (Loki) for similar past errors, queries our production database for affected rows, and outputs a `plan.md` file describing the root cause and proposed fix. Sensitive fields in the database are one-way encrypted; the agent can pattern-match on metadata without ever seeing customer secrets.

Phase 2. Implement. Brand new context window. Claude is handed the `plan.md` (no other context) and writes the code. Runs the unit tests. Spins up a local dev server in a git worktree on a dedicated port. Opens Chromium via the browser MCP. Navigates to the affected page. Takes a screenshot. Reads the dev server logs and the browser console logs. If anything's wrong, it fixes itself.

Phase 3. Code review. Another fresh context window. This one gets the full diff and is told to red-team the implementation. It can edit. If it makes more than a handful of edits, the harness flags the original implementation as `messy`.

Phase 4. Docs update. Yet another fresh context. Given the diff, this agent writes new documentation into the `/docs/` folder for any non-obvious behavior the change introduces, and prunes any docs the change has invalidated. This is how the system gets smarter over time. Tomorrow's tickets benefit from today's lessons.

Phase 5. Push. Bash-script-enforced. Commits the changes, pushes to the deployment branch, monitors that the deploy succeeds. Our deploy time is under 120 seconds. Production is updated before a human would have finished reading the ticket.

There is no pull request. There is no human review. There is no staging environment that a human inspects. This is on purpose.

"If you halfway these systems, you're going to turn some poor senior engineer's entire job into reviewing AI-generated PRs. You have to either YOLO the full way or just not at all." -- Hunter Hodnett, Chipp CTPO

Part 5: The five pillars

Inside the cluster, five disciplines do the heavy lifting. Each of them has a dedicated post on this blog. The short version is here.

1. Context engineering

The model has a finite paper. Everything you put on it, the system prompt, the tool definitions, the file contents you read, the search results, the past conversation, eats space. Run out of space and the system starts compacting (a small model summarizes the context window into a paragraph and replaces the original). Compaction is amnesia. Compaction is where good agents go to hallucinate.

The discipline is engineering what goes into the context window so the agent can finish its job before it runs out of paper. → *Context Engineering: The Skill That Turns Claude Into a Production Co-Developer*

2. CLAUDE.md as scar tissue

Your `CLAUDE.md` is the system prompt that loads in every session. Treat it as a scar tissue document, not an aspiration document. Every line in it is there because you got bitten by a real bug.

When you see the agent make the same mistake three times, stop the session, tell Claude to add a rule to `CLAUDE.md`, and continue. After six months, your `CLAUDE.md` is a textbook of your codebase's hidden rules, and your agents stop making those mistakes forever.

Use the hub-and-spoke model: a root `CLAUDE.md` plus subdirectory `CLAUDE.md`s that auto-load when files in those directories are read. → *CLAUDE.md Architecture: A Hub-and-Spoke Pattern for Autonomous Codebases*

3. Skills and sub-agents

A skill is a chunk of text that loads into the current context window when it's relevant. Like a cheat sheet you carry with you while you work. Useful for things you need *while* coding, design system rules, brand voice, build conventions.

A sub-agent is an entirely separate context window the main agent can spawn. Like sending someone to the library and waiting for them to come back with a one-paragraph summary. Useful for parallelizable work or for investigations that would otherwise pollute your main context.

The decision rule: *does the agent need this knowledge while working, or can it get an answer and come back?* → *Skills vs Sub-Agents: When to Use Each in Claude Code*

4. MCP: Claude's senses

The Model Context Protocol is how the agent perceives the outside world. Without MCP, the agent is reasoning over its training data. With MCP, the agent can read your production logs, query your database, navigate your dev server, take screenshots of your UI.

The single highest-leverage MCP for autonomous development is the browser MCP. It's what lets the agent verify its own work. Build a custom one tied to your application, bake your dev login flow, your seed data, your test scenarios into the tools. The off-the-shelf browser MCPs are great to learn with; they're not what you'll run in production. → *MCP Is the USB-C of AI: Building Your First MCP Server in 30 Minutes*

5. The bash harness

"An autonomous agent without a bash harness is an intern with no manager, no deadline, and an unlimited API budget." -- Hunter Hodnett, Chipp CTPO

Claude is non-deterministic. Your business needs to be deterministic. The bash harness is what reconciles those two.

Concretely, our harness:

• Spawns Claude with `claude -p --dangerously-skip-permissions`.
• Watches the output stream and kills the session if no tool call fires for five minutes.
• Greps for banned flags and aborts if it sees them, `git push --no-verify`, `git reset --hard`, `rm -rf`.
• Forces a final `git commit` and `git push` if Claude forgets.
• Cleans up orphaned dev server processes after each run.
• Writes outcome labels (`clean` / `messy`) for each ticket so the data is ready for fine-tuning later.

→ *Building a Self-Healing Bug Bot: The Autonomous Dev System We Use at Chipp*

Part 6: A real ticket, end to end

Enough abstraction. Here's a real production ticket from last quarter.

The error. An HTTP 500 on `/api/billing` for customers without a default payment method. Stripe's `create_customer` call failed; we weren't catching the failure; the user got a blank page.

The trigger. Loki ingested 47 instances within five minutes. Grafana's alert rule fired. Webhook hit Bug Bot.

The pipeline, twenty tool calls, in order:

1. Read `CLAUDE.md` from the root.
2. Read `docs/billing.md` (auto-loaded by the doc retrieval phase because the ticket mentioned billing).
3. Pull latest staging branch.
4. Read `src/api/routes/billing/index.ts`, the file in the stack trace.
5. `bash: rg "create_customer"`, find every call site.
6. Read `src/services/stripe.ts`, the service wrapper.
7. Query Loki for similar errors over the last seven days. Result: started 90 minutes ago.
8. Query Loki for the deploy that landed 90 minutes ago. A change to default payment method handling.
9. Query the production database for affected customer rows.
10. Form hypothesis: missing null-check on `customer.default_payment_method`.
11. Edit `src/services/stripe.ts` to add the null-check and a friendly fallback.
12. Run unit tests for that file. Pass.
13. Run the full unit test suite. Pass.
14. Spin up dev server on port 5184 (worker 4).
15. Open Chromium via browser MCP.
16. Navigate to `localhost:5184/billing`.
17. Click "Buy Credits" button.
18. Take screenshot. Read browser console logs. No errors.
19. Verify HTTP 402 response with friendly toast message.
20. Commit. Push. Deploy.

The result. A bug that would have taken a junior engineer most of a workday, read the stack trace, find the bad commit, write the fix, test it, ship it, closed in twelve minutes by a process. Cost: about a coffee.

This is what's actually running. Nothing in this section is theoretical. The ticket above is one of about 25 we ship to production in an average day.

"Junior engineer's day done by a process in 12 minutes." -- Hunter Hodnett, Chipp CTPO

A note on anti-fragility

While I was teaching a recent cohort session, Stripe went down for three hours. Half the AI industry's billing infrastructure went silent. The other half's customers couldn't buy.

We barely noticed. Six weeks earlier, I had pointed Bug Bot at "build us a redundant usage-based billing system that runs alongside Stripe." It chewed through the work over a weekend. The system had been sitting in production, in shadow mode, ever since.

When Stripe died, I flipped a feature flag. Our billing kept running. Our customers kept buying.

I bring this up not as a brag but as a description of what changes when your engineering capacity stops being a function of headcount. Redundancies that would have been "nice-to-haves with a six-month timeline" become "weekend tickets for an idle worker." Anti-fragility stops being a Talebian aspiration and starts being a default property of how you build software.

Part 7: Why we're building Alchemist

When Claude Opus 4 dropped, I started using it for live coding sessions. I was sitting at my desk one afternoon, watching lines of code scroll up my screen, code I hadn't typed, code that was fixing things I hadn't asked it to fix yet. My wife came down and asked me what I was actually doing for work anymore. I didn't have an answer.

That was the moment I realized the entire "AI coding assistant" framing was wrong. The AI wasn't an assistant. It was the engineer. I was the manager.

The system you've been reading about is what I built between that afternoon and today. Three years of mistakes compressed into six months of acceleration once the model could carry the weight.

When we showed an early version of it to founders in our Technical Agents of Change cohort, the question kept coming back:

*"Can we have it?"*

Not "can we license it." Not "can we read the code." *Can we have a starter version of this whole apparatus, configured and ready, that we can run on day one?*

So we're building it. We're calling it Alchemist, and we're rolling it out as the first commercial implementation of autonomous development as a service.

Here's what Alchemist gives you on day one:

• A deployed, opinionated stack. Deno on the server, Svelte on the client, Chromium for verification, Cloudflare Workers for hosting. We picked this combination after months of testing because it has the highest LLM training-data density of any modern web stack. Your agents will hallucinate less and ship more in this stack than in any other.
• A configured Claude Code cluster, harness, and verification loop. Pre-wired `CLAUDE.md`, browser MCP, log-drain MCP, and a bash harness that will not let your tokens run away.
• A `/docs/` folder that builds itself as you ship.
• A self-healing pipeline. Errors in production trigger autonomous fixes.
• An integrated customer support agent that escalates real frustration to a human (us, during the alpha).

And the most important part: the eject mechanism.

When you create a project on Alchemist, we create a GitHub repo for you. Every commit Alchemist's workers make goes there. If you decide one day to take your code to a private cloud, save on hosting, or just leave, you take the repo and go. Nothing is locked behind our infrastructure. The Alchemist Deployment Workflow runs on your repo, and you can fork it. We learned a long time ago that the only way to build a sticky business is to make sure your customers are *choosing* to stay every month, not trapped into staying.

The closed alpha is starting now. If you want in, the waitlist is at the top of this page.

Part 8: Who this is for (and who it isn't)

This is not for everyone, and I'd rather lose your attention now than later.

This is for technical builders ready to lead a fleet of agents. People who have shipped software, who can read a stack trace, who know what a tool call is. People who are excited, not threatened, by what AI can do with a codebase.

This is for builders willing to delete their PR review process. I'm serious. If you're attached to "every change gets reviewed by a human before it ships," you're going to half-implement what we describe in this post. Half-implementations are worse than no implementation. Half-implementations turn senior engineers into AI-PR-review janitors and ship slower than the manual baseline. Either YOLO the full way or stay where you are.

This is for teams of one to ten trying to compete with teams of fifty to five hundred. The economics of autonomous development bend hardest in your favor when you're capital-constrained and ambition-rich. We bootstrapped Chipp's autonomous cluster because we had two engineers and a roadmap that wanted twenty.

This is not for engineers who think AI should stay out of the way. I respect the position. I disagree with it. Either way, this isn't the post for you.

This is not for non-technical founders looking for a no-code shortcut. Alchemist is not Lovable. You will write `CLAUDE.md` files. You will read stack traces. You will need to know what a context window is. Our value proposition is *do less of the typing and verification yourself*, not *never touch the code*.

This is not for organizations running on quarterly review cycles. The pace of frontier AI doesn't wait for your governance committee. If your decision-making cadence is slower than a model release cycle, you can't run an autonomous dev cluster. You can experiment with one, but you can't run one in production.

If you've made it this far and you're still nodding, you're our reader. Welcome.

Part 9: What's coming

Over the next eight weeks, we're publishing the operating manual for autonomous development. One piece of the cluster per post:

• Context Engineering: managing the finite paper.
• CLAUDE.md Architecture: the hub-and-spoke pattern, scar tissue practice, auto-load tables.
• Skills vs Sub-Agents: when to use which.
• MCP: building the senses your agents need.
• The Bash Harness: turning Claude into a teammate with commit access.
• Multi-agent Pipelines: serial handoffs, sub-agent dilution, self-healing loops.
• Agentic Design Patterns: the seven we battle-tested at Chipp.
• Vibe Coding vs Autonomous Development: the maturity curve, demystified.
• Beyond AI Pair Programming: from Copilot to Coworker to Autonomous Engineer.

If you want this in your inbox, the waitlist signup at the top of this page also subscribes you to the series.

The bottom line

Software development is being rewritten. Three things will happen over the next twenty-four months:

1. A few teams will adopt autonomous development and ship 30 features a day at a fraction of payroll cost.
2. Most teams will halfway it, turn their senior engineers into AI PR reviewers, and end up worse off than before they started.
3. A handful of teams will resist entirely and watch their competitors lap them.

Which group your business ends up in is being decided right now.

We're betting on group one. We're building Alchemist for the people who are.

Will your engineering team ship the next decade of your product, or will an autonomous cluster ship it for you?

If the answer is the cluster, the question is whose.

[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)

*Hunter Hodnett is co-founder and CTPO of Chipp, the platform behind 125,000+ AI agents that have held 14M+ conversations with real users. He previously engineered at Reddit, Amazon, and The Home Depot, and trained 290+ engineers as a coding bootcamp instructor. Alchemist is Chipp's autonomous development product, currently in closed alpha. The waitlist is open at chipp.ai.*

Each one moved a layer of the stack from a thing you *built* to a thing you *rented*. Each one looked, to the people running the prior layer, like a strange and possibly bad idea. Each one absorbed an entire industry inside a decade.

ADaaS is the next one. Autonomous development as a service productizes the engineering practice itself, the pipeline, the harness, the verification loop, the documentation system, the whole apparatus that lets you point at a goal and get shipped software. You don't rent a tool. You don't rent a model. You rent a *process*.

This post defines the category, separates it from the things it gets confused with, and lays out a buyer's framework for evaluating ADaaS providers, including how to evaluate the one we're building.

The lineage

Pull the thread on every -aaS and you find the same arc.

SaaS turned software from a thing you bought (in a box) into a thing you logged into (in a browser). The category cracked open in 1999 with Salesforce and now houses ~$300B in revenue across thousands of companies. The unit of consumption became "a seat per month" instead of "a license forever."

PaaS turned application infrastructure from a thing you assembled (Apache + MySQL + your own load balancer) into a thing you deployed to (Heroku, Vercel). The unit of consumption became "an app" instead of "a stack."

IaaS turned the hardware itself from a thing you owned (a rack in a colo) into a thing you spun up (an EC2 instance). The unit of consumption became "an hour of compute" instead of "a server lease."

Now look at what's actually been left out of those layers: the engineering practice that turns intent into shipped software. That's still a thing every company builds for itself, with hired engineers, against a backlog. It's the largest unproductized layer left in the software value chain.

ADaaS is what productizes that.

The unit of consumption becomes "a ticket shipped" instead of "an engineer-week." That's a category-defining shift. If the pattern holds, and the underlying economics suggest it will, most software companies in 2030 will buy this layer instead of building it, the same way most software companies in 2010 stopped racking servers.

What you're actually buying

People hear "autonomous development as a service" and assume it's an AI coding tool with a marketing team. It isn't. The category is bigger and more boring than that.

When you buy ADaaS, you're buying:

A configured agent cluster. Not Claude or GPT, the *cluster* on top, with the bash harness, the worker pool, the parallelism management, the timeout enforcement. The thing that turns a non-deterministic model into a deterministic teammate. (Why this matters →)

A verification loop. A browser MCP that knows how to spin up your dev server, navigate your routes, take screenshots, read console logs. Without this, the agent's writing code and hoping. With it, the agent's writing code and *checking*.

A context-engineering apparatus. A `CLAUDE.md` you don't have to write from scratch. An auto-load table that knows what to load when. Sub-agent definitions for the parts of your codebase that need their own attention. (The discipline behind it →)

A documentation system that builds itself. Every successful ticket writes its own docs. Tomorrow's tickets are smarter than yesterday's because the system never forgets a lesson it already paid to learn.

A maintained MCP fleet. Stripe, GitHub, Cloudflare, Loki, your database, all wired up, all kept current, all hardened against the failure modes the provider has already encountered.

A self-healing pipeline. Errors in production trigger autonomous fixes. The on-call rotation goes empty. PagerDuty escalations stop happening because the cluster is faster than the page would have been.

An eject mechanism. This one matters. The whole stack should be portable, your code lives in your repo, your data in your buckets, your secrets in your vault. If the provider raises prices into a corner, you take your code and walk. ADaaS without an eject mechanism is platform lock-in disguised as a service.

What you're *not* buying:

• A model. The model is upstream of the cluster. You're buying the apparatus that uses the model.
• A code generator. Code generation is one tool call inside the pipeline. The pipeline is what makes generation reliable enough to ship.
• An IDE. ADaaS is unattended by definition. There's no human in the inner loop, so there's no IDE in the inner loop either.
• A no-code builder. ADaaS expects you can read a stack trace. If you can't, the category isn't for you.

How ADaaS is different from what came before

The clearest way to understand a new category is by what it isn't.

ADaaS vs Cursor / Copilot. Cursor and Copilot are *human-in-the-loop* tools. The human is at the keyboard; the AI augments the human. ADaaS removes the human from the inner loop. The human is at the *meta*-loop, defining tickets, reviewing outcomes, making judgment calls. The AI is doing the engineering.

ADaaS vs Devin / Cognition. Devin is the closest competitor in the category, and the comparison is fair. The differences are stack-specific (we tune for one stack and ship a polished cluster around it; Devin works across many) and posture-specific (we ship straight to production with no PR; Devin defaults to a human review gate). Both are valid. Both are autonomous development. ADaaS as a category covers both.

ADaaS vs Lovable / Bolt / v0. These are *vibe-coding-as-a-service* products, marketed at non-technical builders. They're great for prototypes, demos, and weekend projects. They are not autonomous development. They run a model, they show the user the diff, they let the user accept or reject. The human is in the loop on every change. ADaaS removes that loop.

ADaaS vs OpenAI's Codex / Anthropic's Claude Code. These are the *primitives* on which ADaaS is built. They're powerful interactive tools. Hunter writes most of his daily code in Claude Code, but they require a person at the keyboard to drive each session. ADaaS is what you build *on top of* these primitives to remove the person.

ADaaS vs your in-house engineering team. This is the comparison that matters most for buyers. An in-house team has organizational context an outside service can't have. An ADaaS provider has accumulated infrastructure your in-house team would need to rebuild. The right answer for most companies in the next 36 months is *both*, your team focuses on architecture, judgment, and the parts of the codebase that need real human eyes; the ADaaS cluster handles the volume of routine tickets that would otherwise drown a small team.

"ADaaS removes the human from the inner loop. That's the line that separates this category from everything else." -- Hunter Hodnett, Chipp CTPO

Why this is happening now

Three things had to be true at the same time for ADaaS to be a real category. They became simultaneously true in late 2025.

1. Models capable enough to ship code. Claude Opus 4 was the inflection point. Below that capability bar, you can't trust the agent to write production code without supervision. Above it, you can. The bar moved up sharply with Opus 4 and has stayed up.

2. Tool surface rich enough to verify. The Model Context Protocol gave us a standard for browser control, log queries, database access, screenshot capture. Without verification, you can't autonomy. With it, you can.

3. Context-engineering practice mature enough to scale. The discipline of *what to put in front of the model so it doesn't compact, hallucinate, or get lost* didn't exist as a named field two years ago. It exists now. (The full discipline →)

When all three are simultaneously true, autonomous development becomes possible. When it becomes possible at one company, the rest of the industry has 18 to 36 months before they have to either adopt or get outpaced. We're in month four.

The buyer's framework

If you're considering ADaaS for your team, here's the framework I'd run a provider through. Most don't pass. The ones that do are the ones worth paying for.

Question 1: What does your verification loop look like?

If the answer is "we run tests after generation," that's vibe coding with a CI bolt-on. Pass.

If the answer is "we open a browser, navigate to the affected page, take a screenshot, and read the console logs," that's autonomous development. Continue.

The verification loop is the single highest-leverage component. Without it, the cluster is guessing.

Question 2: How do you handle context overflow?

If the answer is "we have a 1M token context, you'll be fine," they don't understand the problem. Compaction will eat them.

If the answer is "we use a multi-stage pipeline, each stage gets a fresh context window, stages communicate via markdown files written to disk," they get it.

Question 3: What's your eject mechanism?

If the answer is "you log in to our platform and use our IDE," you're locked in.

If the answer is "your code is in your GitHub repo, our deployment workflow runs in your CI, you can stop paying us tomorrow and keep everything we built for you," they pass.

This is the deal-breaker for me. ADaaS without an eject is just SaaS lock-in with extra steps.

Question 4: Where does the system get smarter?

If the answer is "as the model gets better," the provider is a passthrough. Your investment in them doesn't compound, you're paying for someone else's improvements.

If the answer is "the documentation our cluster writes for your codebase compounds; the scar-tissue rules in your `CLAUDE.md` accumulate; the outcome-labeled training data we archive becomes the basis for fine-tuning," they're building you a moat.

Question 5: Show me the failure modes

Any honest provider should be able to tell you exactly when their cluster fails and why. If they can't, they haven't run it long enough to know. If they can but won't, they're hiding something.

Our cluster fails on cross-tool integrations (third-party APIs the agent can't directly observe), on decomposition of large features, on truly novel work that has no analog in our codebase. We say so out loud. We'd be suspicious of any provider that doesn't.

Why we coined the term

You'll notice we've been using "ADaaS" throughout this post like it's an established category name. It isn't. We started using it in early 2026. As of this writing, the search volume is low and the SERP is mostly dental-school applications.

We could have used "AI coding agent platform" or "autonomous coding service" or any of a dozen existing labels. We didn't, because none of them name the thing we're actually selling. The category needs a name. Categories that don't have names don't get bought.

So: ADaaS. Autonomous development as a service. Coined here, defined here, with the working understanding that the rest of the industry will catch up to it within 12 to 18 months because the underlying economic logic is too powerful to stay underground.

If we're wrong about the category, the term dies. If we're right, you'll be hearing it a lot.

"Categories that don't have names don't get bought. We named ours." -- Hunter Hodnett, Chipp CTPO

Where Alchemist sits

Alchemist is our implementation of the category, the configured cluster, the verification loop, the documentation system, the eject mechanism, the maintained MCP fleet. The same system that runs Chipp's autonomous engineering (the system I described in the manifesto) is what we're packaging.

We expect competitors. We're going to write about them when they ship; the category is bigger than any one company can capture, and the work of category-defining is mostly happens in public, in posts like this one.

What we're going to differentiate on:

• Stack opinionation. We picked one stack (Deno, Svelte, Cloudflare) and tuned the cluster against it. Generality is a tax. Specialization is a moat.
• Eject by default. Your code is in your repo from day one. We win because you choose to stay, not because you can't leave.
• Bundle of practice, not just product. The cluster comes with the disciplines that make it work, `CLAUDE.md` patterns, sub-agent definitions, verification loops, doc system. You inherit two years of practice the moment you sign up.

The closed alpha is starting now.

The bottom line

Software development is the largest unproductized layer left in the software value chain. ADaaS is what productizes it. The pattern matches every prior -aaS revolution, the technology is suddenly capable, and the disciplines for using it are no longer secret.

The teams that adopt early will build software at engineering capacities a team an order of magnitude larger could not match. The teams that hold out will spend the next 24 months watching that gap widen.

If you've read this and you're nodding, you're our buyer.

[Join the Alchemist waitlist →](https://chipp.ai/#waitlist)

If you want the long-form case for autonomous development, start with The Autonomous Development Manifesto.

If you want to see what an ADaaS implementation looks like under the hood, read Building a Self-Healing Bug Bot.

This is a meaningfully different posture from the AI coding assistants most engineers use day-to-day. It's worth pinning down what the term actually means before unpacking how it works in practice.

A working definition

An autonomous software development system has four properties:

1. A bounded task input. Usually a GitHub issue, a Slack message, a customer support ticket, or a natural-language description. The input names a goal, not a sequence of steps.
2. Tool-mediated execution. The agent works through a constrained interface (`read_file`, `write_file`, `run_tests`, `push_changes`) rather than free-form output. Tools provide accountability and a place to enforce safety.
3. A self-terminating loop. The agent decides when it's done. Either it pushes a commit, or it exhausts a turn budget and reports failure. There is no human in the middle of the loop.
4. An auditable result. Every decision the agent made is recoverable from the conversation log, the tool calls, and the final diff. Someone can read the trail and decide to merge, revise, or reject.

If any of those is missing, you have something else. A system that requires a human to pick the next file to edit is an assistant. A system that emits code without running it is a generator. A system without a clear stop condition is a research demo.

How it differs from coding assistants

GitHub Copilot, Cursor's autocomplete, and most IDE-resident AI features operate at the keystroke or block level. They predict the next token given the current cursor position. The human is doing the engineering, choosing which file to open, which abstraction to introduce, when the work is done. The AI is making the typing faster.

Autonomous systems invert that ratio. The human writes a paragraph; the AI does the engineering. That shift matters because the bottleneck on most software teams is not how fast people can type, it's how much *coordinated cognitive load* a single change requires. Reading the existing code. Understanding the bug. Writing the fix. Writing the test. Reviewing the diff. Pushing without breaking anything else. That whole stack is what an autonomous system is trying to absorb.

How it works in practice

Concretely, every modern autonomous coding system looks roughly the same on the inside:

Issue → System prompt + tools → LLM tool-use loop → Push

The agent runs in a sandbox: a container, an E2B microVM, sometimes a fresh Kubernetes Job per ticket. Inside the sandbox, the repo is cloned, a model like Claude or GPT-4-class is given the issue plus a tool schema, and the model decides what to do next. Each model turn either calls a tool or stops. The framework executes the tool, feeds the result back, and asks the model what's next.

Most systems put a self-review step before push: the agent runs `git diff` on its own work, critiques it as a separate model call, and either fixes the issues it finds or proceeds. This single trick, letting the model see its own work before committing, is one of the largest quality wins in the space.

What it can do today

Autonomous systems work well on:

• Well-scoped bug fixes. "Date parsing breaks when the timezone is null": clear input, finite blast radius, a test that proves the fix.
• Mechanical refactors. Rename a symbol across a repo. Migrate a library. Update an API call site.
• Feature scaffolding. "Add a new resource called `Project` with the same CRUD shape as `Tenant`": the pattern already exists in the codebase, the agent just instantiates it.
• Tests written from existing behavior. Pin down what the code does today so it can be refactored tomorrow.

What they're not yet good at (and where the field is actively working) is anything that requires *holding the whole system in your head*. Cross-cutting performance work. Ambiguous product decisions. Architectural changes that touch every layer at once. Those still need a human.

Why this matters

Autonomous software development changes the unit of engineering work from "a person-day" to "a ticket". The ticket is the smallest thing you can hand off. If a system can reliably absorb tickets, then the question stops being "how many engineers do we have" and starts being "how many tickets can we describe well enough to ship". The bottleneck moves up the stack: to specification, to testing, to code review.

This is what we're building Alchemist around. Tickets in, code out, with a transparent trail of every decision the agent made along the way. We'll be writing about the parts that turned out to be harder than they looked (sandboxing, billing per turn, the model's tendency to over-edit, what self-review actually catches) in posts that follow.

If you want to be early, join the waitlist. If you want to be very early, the engineering posts are the place to read along.

InForum is the daily paper of record for Fargo-Moorhead. Real reporters. Real datelines. Real sources on the ground. When something happens in North Dakota, they're who covers it.

They're also completely invisible to ChatGPT.

Ask Claude what happened at last night's Fargo city council meeting and it cannot cite them. Not because the article doesn't exist — it does, with a named byline, a dateline, three sources quoted by title. The article just can't be retrieved. InForum has blocked every AI crawler on the planet.

We found that in 60 seconds. Tomorrow's GEO: SEO for AI workshop runs this same audit live on your site. Save your seat →

🎥 The Live Audit

See the results in real time and get a peek at what you will walk away with:

Composite Score: 41/100. Grade: D.

We pointed Chipp's GEO Audit Agent at inforum.com. The "agent" is actually a team — Visibility Analyst, Platform Optimizer, Technical SEO Auditor, Content & E-E-A-T Analyst, Schema Architect, Report Agent — all led by a GEO Strategist.

Three findings came back. Any one of them would hurt. Together, they explain why InForum loses AI-referred traffic every single day.

Finding #1 — Every AI Crawler Is Blocked. Every One.

InForum's `robots.txt` explicitly disallows 100+ AI user-agents: GPTBot, ClaudeBot, PerplexityBot, Google-Extended (which powers AI Overviews), Gemini-Deep-Research, OAI-SearchBot, Meta-ExternalAgent, MistralAI, DeepSeekBot, and dozens more — blanket `Disallow: /`.

This isn't a training-data opt-out. It's a total citation blackout.

No AI engine can index, retrieve, or cite a single page on inforum.com. When a Fargo resident asks ChatGPT *"what happened at the council meeting last night,"* InForum cannot be the answer — even if InForum is literally the only place that answer exists.

The fix is one line. Delete a few rules in `robots.txt`. Highest-ROI action in all of GEO, and it's free.

Finding #2 — No llms.txt. 404.

`inforum.com/llms.txt` doesn't exist. Zero structured AI content guidance. No curated index of coverage areas, reporter roster, or authoritative work.

Even if the crawler block dropped tomorrow, AI engines would walk in without a map. A 2–4 hour draft would establish topical authority for ND/MN news at zero ongoing cost.

Finding #3 — The Journalism Is Great. The AI Can't Reach It.

Here's the frustrating part. Individual InForum articles score 78–82/100 for AI citability:

• Named bylines with author bios
• Geographic datelines (*DILWORTH —*, *BISMARCK —*)
• Precise timestamps and specific data points
• Named sources with titles
• Fact-dense, self-contained passages

That's exactly what AI engines cite. The reporters are doing the work. The paywall plus the crawler block lock it all behind two doors — and no AI can open either one.

Great content. Zero distribution to the fastest-growing channel in marketing.

This Isn't an InForum Problem

AI-referred traffic is up 527% year over year. It converts 4.4x higher than organic search. Gartner projects traditional search drops 50% by 2028. Only 23% of marketers are doing anything about it.

Most sites we audit have at least one of InForum's three issues. Plenty have all three.

The gap between *"cited by ChatGPT"* and *"invisible to ChatGPT"* is almost never a content problem. It's a configuration problem most teams don't know they have.

What Tomorrow's Workshop Covers

Thursday, April 23, 2026 — 90 minutes live. GEO: SEO for AI.

You'll leave with:

• A live audit of your site. Same 60-second audit we ran on InForum. On the call. Your URL.
• The GEO Audit Agent template inside Chipp. The 6-specialist team above, yours to deploy on any site on demand.
• The agency sales playbook. How agencies are pricing GEO retainers at $2K–$12K/month — discovery scripts, cold email templates, objection handling.
• Platform-specific optimization guides. What ChatGPT cites vs. Perplexity vs. Google AIO. Only 11% overlap.

Who it's for:

• Marketing leads and in-house SEO teams — add GEO to your 2026 strategy before Q3.
• Agencies and consultants — add a high-margin service line your clients don't know they need yet.
• Founders — most of your competitors aren't optimizing for AI search yet. This is your window.

Run the Audit on Your Own Site

Easiest place to start: open your own `robots.txt` right now. Search for `GPTBot`, `ClaudeBot`, or `Google-Extended`. If any of those have a `Disallow`, you're leaving AI-referred traffic on the table the same way InForum is.

Then check `yourdomain.com/llms.txt`. If it's a 404, that's finding #2.

Fixing both takes an afternoon. Knowing the other 40 things to fix takes a workshop.

**Save your seat for tomorrow's live GEO workshop →**

What you'll find here

• Architecture deep-dives. How our Alchemist, tool-execution pipeline, vector search, voice stack, and billing system actually work.
• Postmortems. What broke, why, and how we fixed it. Public so other teams building AI platforms can skip the same mistakes.
• Performance and scale. Work we're doing to keep p95 latency tight as we ship 20–30 deploys a day to production.
• Decisions. Why we picked Deno, why we wrote our own Stripe token billing layer, why we use a Cloudflare Worker as an edge proxy in front of everything.

Why a separate blog

Our docs are reference material — how to use the platform. The Ghost blog is for product news and announcements. This is different: it's the engineering reasoning behind the product, written for people who build things.

If that's useful to you, the RSS feed is the easiest way to follow along.

For the past year, we've been trying to show up in ChatGPT, Claude, Perplexity, and the rest of the AI search engines. We thought we were doing everything right.

Then we discovered our own host was blocking the AI bots from crawling our content.

We were invisible. And we had no idea.

So we did what we always do — we built a platform to fix it. And on Thursday, April 23, we're running a free 90-minute workshop to show you exactly how it works, how to use it on your own site, and how agencies are turning this into a $2K–$12K/month service line.

Register for the Workshop

The Rules of Search Just Changed

Most marketers haven't noticed yet. Here's what the data says:

• AI-referred traffic is up 527% year-over-year
• It converts 4.4x higher than organic search
• Gartner projects traditional search traffic will drop 50% by 2028
• Only 23% of marketers are doing anything about it

The businesses showing up in ChatGPT, Claude, Perplexity, Gemini, and Google AI Overviews are capturing the traffic that used to go to Google. The ones that aren't are getting quieter every month — and most don't realize it's happening.

GEO Isn't SEO

Generative Engine Optimization is a completely different discipline. AI engines don't care about your backlink profile. They care about:

• Citability — AI-cited passages cluster in a specific 134–167 word range with specific structural properties
• Crawler access — many sites accidentally block AI bots in robots.txt (we did)
• Brand mentions across YouTube, Reddit, Wikipedia, LinkedIn — these correlate 3x more strongly with AI citation than backlinks
• Schema markup — the structured data telling AI engines what your site actually is
• E-E-A-T signals — authorship, credentials, primary sources

Only 11% of citations overlap between ChatGPT, Perplexity, and Google AI Overviews. Each engine has to be optimized differently.

What You'll Walk Away With

Join us for our GEO workshop.

You'll walk away with:

• A live audit of your own site. We'll run it on the call.
• The GEO Audit Agent template inside Chipp — a team of 6 AI specialists led by a GEO Strategist: --AI Visibility Analyst --Platform Optimizer --Technical SEO Auditor --Content & E-E-A-T Analyst --Schema Architect --Report & CRM Agent

It audits any website on demand.

• The agency sales playbook — how agencies are pricing GEO retainers at $2K–$12K/month. Discovery scripts. Cold email templates. Objection handling.
• Platform-specific optimization guides — what ChatGPT cites vs. what Perplexity cites vs. what AIO cites.

Who This Is For

• Marketing leads and in-house SEO teams — add GEO to your 2026 strategy
• Agencies and consultants — add a high-margin service line your clients don't know they need yet
• Founders — most of your competitors aren't optimizing for AI search. This is your window.

The Bigger Picture

What's happening with AI tools like Chipp isn't "AI for marketers" or "AI for dentists." It's helping agencies become AI agencies, accountants become AI accountants, consultants become AI consultants.

Chipp is becoming the platform where all of your business information lives — and gets put to work. GEO is one of the clearest examples of that. We use it ourselves. On Thursday, we'll show you how to use it too.

GEO: SEO for AI Thursday, April 23, 2026 · 11:00 AM – 12:00 PM Free · Online

Reserve Your Spot

Looking for a quick definition? See our AI Chat glossary entry.

---

In 1966, a MIT professor named Joseph Weizenbaum built a program called ELIZA. It could hold a conversation — sort of. It matched patterns in your sentences and spit back therapist-style questions. "Tell me more about that." People loved it. Some genuinely believed they were talking to something that understood them.

ELIZA understood nothing. It was a parlor trick with parentheses.

Sixty years later, AI chat isn't a parlor trick anymore. It's the interface layer for a new era of software — one where you talk to your tools instead of clicking through them. And the gap between ELIZA and what's possible today isn't just technical. It's philosophical. We went from pattern matching to genuine comprehension.

What AI Chat Actually Is

AI chat is a conversational interface powered by artificial intelligence. Instead of navigating menus, filling out forms, or scrolling through help docs, you just... talk. Type a question, get an answer. Describe what you need, and the system figures out how to deliver it.

At its core, an AI chat system takes natural language input — the way humans actually communicate — and generates relevant, contextual responses. That's the simple version.

The more accurate version: modern AI chat combines large language models (LLMs), retrieval systems, and conversation memory to hold coherent, multi-turn dialogues that can accomplish real tasks. Not just answering questions, but booking appointments, troubleshooting problems, writing code, analyzing documents, and making recommendations based on your specific situation.

This is different from the chatbots of five years ago, which followed rigid decision trees. Ask something unexpected and they'd break. Today's AI chat systems handle ambiguity, follow context across long conversations, and adapt their responses based on who they're talking to and what they know.

The term gets used broadly — "ai chatbot," "chat ai," "artificial intelligence chat" — but they all point to the same fundamental shift: software you talk to instead of operate.

How AI Chat Works Under the Hood

You don't need a PhD to understand this, but it helps to know the basics.

Modern AI chat runs on large language models — neural networks trained on massive datasets of text. These models learn the statistical relationships between words, sentences, and ideas. When you send a message, the model doesn't look up an answer in a database. It generates one, token by token, based on the patterns it's learned and the context you've provided.

Three components make this work in practice:

The language model itself. This is the brain — GPT-4, Claude, Gemini, or any number of foundation models. It handles understanding your input and generating coherent responses. The quality of the model determines the ceiling of what your AI chat can do.

The knowledge layer. A raw language model knows what it was trained on, but it doesn't know *your* business, *your* products, or *your* policies. This is where retrieval-augmented generation (RAG) comes in. You feed the system your documents, FAQs, product specs, whatever — and it pulls from that knowledge when responding. This is how an AI chat for a law firm knows about your specific practice areas, or how an e-commerce chatbot knows your return policy.

Conversation memory. Good AI chat remembers what you said five messages ago. It tracks context across a conversation so you don't have to repeat yourself. Some systems even maintain memory across sessions, so returning users get a personalized experience.

Put these three together and you get something that feels less like a tool and more like a knowledgeable colleague who happens to be available 24/7.

The Three Species of AI Chat

Not all AI chat is created equal. The landscape breaks into three distinct categories, each solving different problems.

General-Purpose Assistants

These are the ChatGPTs and Claudes of the world — broad, capable, and designed to handle virtually any topic. Need to brainstorm marketing copy? Debug Python code? Explain quantum mechanics to a 10-year-old? General assistants do it all, but they don't know anything specific about your business.

Think of them as brilliant generalists. Great for individual productivity, but not purpose-built for any particular use case.

Customer-Facing AI Chat

This is where things get interesting for businesses. Customer-facing AI chat sits on your website, in your app, or on your messaging channels and handles the conversations your team used to handle manually. Support questions, product recommendations, appointment scheduling, lead qualification.

The best customer-facing AI chat doesn't feel like a bot. It feels like your most knowledgeable team member — the one who's read every document, memorized every policy, and never has a bad day.

A hotel chain using AI chat generated $26,000+ in direct bookings in two weeks. Not because the AI was pushy. Because it was helpful, available at 2 AM when guests were planning trips, and knew the property inside out.

Specialized and Vertical AI Chat

This is the frontier. AI chat built for specific industries, specific workflows, specific expertise. A legal AI chat that understands case law. A medical AI chat that can triage symptoms against clinical guidelines. A real estate AI chat that knows neighborhood comps and can walk buyers through financing options.

Vertical AI chat is where the real value lives because domain expertise is expensive and scarce. An AI chat trained on a specialist's knowledge can scale that expertise to hundreds of simultaneous conversations.

How Businesses Actually Use AI Chat Today

Theory is nice. Here's what's happening in practice.

Customer support that doesn't sleep. The most obvious use case, and the most impactful. AI chat handles the 70-80% of support questions that are repetitive — order status, return policies, how-to questions — and escalates the complex stuff to humans. The result: faster response times, lower costs, and support teams that focus on problems worth their expertise.

Sales and lead qualification. An AI chatbot on your pricing page can answer questions, handle objections, and qualify leads before they ever talk to a salesperson. One automotive group uses AI chat to handle inbound inquiries across multiple dealerships, routing qualified buyers to the right team with full context of the conversation.

Internal knowledge bases. Companies are deploying AI chat internally so employees can query company policies, technical documentation, and institutional knowledge conversationally. Instead of searching through a 200-page employee handbook, you ask a question and get the answer.

Professional services. Consultants, coaches, therapists, and educators are using AI chat to extend their reach. A nutritionist builds an AI chat trained on their methodology — clients get guidance between sessions. A business coach creates an AI chat that can walk prospects through a framework before the first paid call.

E-commerce and product discovery. "I need running shoes for flat feet under $150 that work on trails." Traditional search and filters can't handle that. AI chat can. It's turning product catalogs into conversations.

Building Your Own AI Chat (It's Easier Than You Think)

Here's where the landscape has shifted dramatically. Two years ago, building an AI chat meant hiring engineers, wrestling with APIs, managing infrastructure, and burning through months of development time.

That's no longer true.

Platforms like Chipp have compressed the entire process into something a non-technical person can do in an afternoon. Upload your documents, customize the personality and instructions, choose your model, and deploy. Your AI chat is live — on your website, shareable via link, or embedded wherever your audience is.

The process looks roughly like this:

1. *Define what your AI chat should know.** Upload PDFs, paste URLs, add text documents. This becomes your AI chat's knowledge base.
2. *Set the instructions.** Tell it how to behave, what tone to use, what topics to focus on, what to avoid. This is where your expertise shapes the AI's personality.
3. *Choose your model and settings.** Different models have different strengths. Some are faster, some are more capable, some are more cost-effective. Chipp's docs walk through the tradeoffs.
4. *Deploy and iterate.** Launch it, watch the conversations, refine. The best AI chat systems improve over time because you can see exactly where they succeed and where they need adjustment.

The barrier to entry has dropped to near zero. The differentiator now isn't technical capability — it's the quality of your knowledge, the clarity of your instructions, and how well you understand your users' needs.

If you're evaluating options, Chipp's pricing is straightforward — no per-seat charges, no conversation limits that punish growth.

Where AI Chat Goes From Here

We're still in the early innings.

The next wave of AI chat won't just answer questions — it'll take actions. Book the flight. File the document. Update the CRM. Process the refund. We're moving from conversational interfaces to conversational agents, and the line between "chat" and "workflow" is dissolving.

Voice is accelerating this. AI chat is expanding beyond text into natural spoken conversations. Call a business and talk to an AI that sounds human, knows your account history, and can actually resolve your issue. The phone tree — that relic of the 1990s — is finally dying, replaced by AI chat that actually listens.

Multimodal capabilities are expanding too. Send a photo of a broken appliance and get troubleshooting steps. Share a screenshot of an error message and get a fix. AI chat is becoming the universal interface — not just for text, but for any kind of input.

The businesses that move now — building their AI chat, training it on their expertise, deploying it to their customers — will have a compounding advantage. Every conversation makes the system smarter. Every edge case you handle improves the next interaction. Waiting means playing catch-up against competitors whose AI chat has been learning for months.

Frequently Asked Questions About AI Chat

What is AI chat? AI chat is a conversational interface powered by artificial intelligence that can understand natural language, hold context across a conversation, and generate helpful responses. Unlike traditional chatbots that follow scripts, modern AI chat systems use large language models to handle complex, nuanced questions.

Is AI chat the same as a chatbot? Not exactly. Traditional chatbots follow pre-programmed decision trees — they can only handle questions they were explicitly designed for. AI chat uses language models that can understand and respond to virtually any input, handle ambiguity, and maintain context across long conversations. Think of it as the difference between a vending machine and a personal assistant.

How much does it cost to build an AI chat? It ranges widely. Custom development can run tens of thousands of dollars. No-code platforms like Chipp start at a fraction of that — you can build and deploy a fully functional AI chat in hours, not months. The cost depends on conversation volume, model choice, and features you need.

Can AI chat replace human customer support? It can handle the majority of routine inquiries — often 70-80% of volume — but the best implementations use AI chat to augment human teams, not replace them. AI handles the repetitive questions instantly, and humans focus on complex, emotional, or high-stakes conversations.

Is AI chat secure? Security depends entirely on the platform you choose. Look for SOC 2 certification, data encryption, and clear data handling policies. Reputable platforms don't train on your conversations or share your data.

What's the difference between AI chat and ChatGPT? ChatGPT is one specific AI chat product made by OpenAI. "AI chat" is the broader category — any conversational AI interface. You can build your own AI chat trained on your specific knowledge, branded to your business, and deployed on your own channels.

How do I build an AI chat for my business? The fastest path: choose a platform like Chipp, upload your knowledge base (documents, FAQs, product info), set instructions for how the AI should behave, and deploy. No coding required. The whole process can take less than an hour.

Here are the highlights from the week that was in AI and our spicy takes on what it actually means. 🌶️

This week in AI:

• Mark Zuckerberg is building a "CEO agent" to help him run Meta
• Cargill is using AI machine vision to squeeze an extra $200M worth of meat from beef carcasses annually
• A man with zero biology background used ChatGPT and AlphaFold to design a custom mRNA cancer vaccine for his rescue dog — and it worked
• NBC poll shows AI has a -20 net favorability rating, worse than every institution except Iran

The theme this week: AI is delivering massive practical wins while public trust still lags. The capability curve is moving fast — adoption and perception are still catching up.

On the Chipp side: Hands-on workshops running every week to help you build and sell AI agents. Upcoming events include:

• Agents of Change cohorts

AI Highlights from Around the Web

Zuckerberg Is Building an AI Agent to Help Him Be CEO

Mark Zuckerberg is building a "CEO agent" to assist with his role running Meta, according to a report from Meghan Bobrowsky. Internally, employees are adopting AI tools called "My Claw" and "Second Brain," and are being graded on AI usage as the company pushes to speed up work across the organization.

https://x.com/MeghanBobrowsky/status/2035849211468767595?ref=chipp.ai

If image doesn't load, view tweet: https://x.com/MeghanBobrowsky/status/2035849211468767595?ref=chipp.ai

*Grading employees on AI usage is the quiet part said loud. When adoption metrics become performance metrics, "optional" tools stop being optional. Whether this produces better work or just more AI-generated busywork is the billion-dollar question every company adopting these policies should be asking.*

AI Is Squeezing an Extra $200 Million Worth of Meat from Beef Carcasses

Cargill is using a machine vision tool called "CarVe" that spots tiny flecks of meat — "red pixels" — in images of beef carcasses. The tool recovers 0.5% more meat from each animal, totaling 55 million pounds annually (~$200M worth). This comes as beef prices are up 17% year-over-year with cattle herds at their lowest levels in 75 years.

https://x.com/TrungTPhan/status/2035472879836594308?ref=chipp.ai

If image doesn't load, view tweet: https://x.com/TrungTPhan/status/2035472879836594308?ref=chipp.ai

*This is AI at its most unsexy and most valuable. No chatbot, no agent, no vibes — just computer vision finding meat that human eyes miss. A 0.5% improvement sounds tiny until you multiply it by every carcass Cargill processes. The best AI use cases are often the ones nobody tweets about (ironic, given we found this on Twitter).*

One Man, One Chatbot, and $3,000 Just Outperformed the Pharmaceutical Pipeline

An Australian tech worker adopted a rescue dog with terminal cancer. With zero background in biology, he paid $3,000 to sequence the tumor's DNA, fed it to ChatGPT and AlphaFold, identified mutated proteins and drug targets, and designed a custom mRNA cancer vaccine from scratch. A genomics professor was "gobsmacked." After three months of ethics approvals, the dog received the first injection. The tumor halved. The dog is alive and happy.

https://x.com/IterIntellectus/status/2032858964858228817?ref=chipp.ai

If image doesn't load, view tweet: https://x.com/IterIntellectus/status/2032858964858228817?ref=chipp.ai

*This is the story you show people when they ask what AI is actually good for. Not replacing jobs, not generating slop — helping someone with no domain expertise navigate the most complex science on the planet to save a life. The ethics approval took longer than designing the vaccine. That tells you everything about where the real bottlenecks are.*

AI Now Has Worse Poll Numbers Than ICE

An NBC poll shows AI has a -20 net favorability rating among the public. As Frank Luntz points out, the only things with worse favorability are Iran (-53) and the Democratic Party (-22). AI is less popular than ICE, Congress, and basically everything else that was tested.

https://x.com/FrankLuntz/status/2030748772620460357?ref=chipp.ai

If image doesn't load, view tweet: https://x.com/FrankLuntz/status/2030748772620460357?ref=chipp.ai

*This is the gap between what AI can do and what people feel about it. The same week someone cured their dog's cancer with ChatGPT, the general public rates AI below ICE. The industry has a massive narrative problem. Building amazing things doesn't matter if regular people associate AI with job loss, deepfakes, and corporate buzzwords. Forcing AI usage as a *key* *metric* could be part of the *problem! *This is why what we do at Chipp matters — making AI accessible and practical closes the perception gap one real use case at a time.*

Chipp Updates

Upcoming Events

• Chipp Platform Training — Learn the ins and outs of building on Chipp with Scott Meyer. Register here

Go Deeper with Agents of Change

Our cohort-based programs teach you how to build and sell AI agents — whether you're technical or business-focused. Learn more and join.

Stay Connected

• Subscribe to Chipp on YouTube
• Follow us on X/Twitter

Tweets Used

• @MeghanBobrowsky/2035849211468767595
• @TrungTPhan/2035472879836594308
• @IterIntellectus/2032858964858228817
• @FrankLuntz/2030748772620460357

We've watched over 20,000 people build AI agents and apps on Chipp. Some charge nothing. Some charge $5,000 a month. The difference isn't the technology. It's how they position it.

So we ran a workshop on exactly this. Here's everything we covered — and everything you need to know to actually get paid for AI work.

Here's the full replay video and slides here with highlights shared throughout. Subscribe on YouTube for future event replays!

How to Sell AI: Pricing, Positioning & Getting Paid (Full Workshop)

The Big Shift Nobody's Talking About

Service is becoming a product. Products are becoming services.

If you're an agency or consultant selling AI services, you're probably already building repeatable deliverables that look a lot like products. And if you're building an AI product, you're probably getting pulled into consulting — onboarding calls, custom prompts, integration help.

The line between products and services is dissolving. And that's actually a good thing, because it means you can start in either camp and borrow from the other.

• Products give you scale and a larger market. But they're lower-priced and harder to customize.
• Services give you higher prices and deep customization. But they eat your time and are harder to scale.

AI blurs these together. A well-built agent is a product that delivers a service. That's the unlock.

The Three Eras of AI (And Why They Change How You Charge)

Ben Thompson recently shared three clear eras of AI:

Chatbots (2022): You ask, it answers. One pass. Done. Cost per interaction: fractions of a penny.

Reasoning (2024): You ask, it thinks. It drafts, reviews, considers tone, rewrites weak parts, then gives a final version. Cost: a few cents.

Agents (2025): You say “handle my customer support inbox.” It reads, reasons, drafts, checks policy, verifies facts, sends, logs, and repeats. Cost: a few dollars.

Each era is more powerful and uses more compute. The impact scales. So does cost. If you price it right, so does revenue.

You can imagine that previously a human was needed to talk to a chatbot and to invoke a reasoning model. Now, there is no bottleneck with humans. An agent can spin up unlimited numbers of reasoning chatbots - the scale grows exponentially. So does the cost and hopefully impact.

Stop Comparing AI to Software. Start Comparing It to Labor.

This is the single biggest framing shift when selling AI.

• Customer support rep: roughly $4,000/month fully loaded, maybe ~50 conversations/day
• AI agent: roughly $150–300/month in token usage for similar workload
• Typical savings: 90–95%

The usage bill isn’t the cost — it’s the savings receipt.

The Old Way vs. The New Way of Pricing

Old way: seat-based. Pay per user whether used or not.

New way: usage-based. Pay for work done. Slow month = low bill. High-output month = higher bill tied to value delivered.

Four Pricing Models and When to Use Each

In his book *Scaling Innovation*, Madhavan Ramanujam and Eddie Hartman lay out the different billing models in the Age of AI.

Seat-based: Best when value scales with human users. Risk: caps upside if AI replaces labor.

Usage-based: Best when usage tracks value/cost (support, voice, API). Risk: unpredictable bills can scare finance.

Outcome-based: Best alignment with ROI (per resolved ticket, qualified lead, successful workflow). Risk: attribution trust.

Hybrid (base + usage): Often best for AI. Predictability for buyers, upside for builders.

How to Price AI Services

Charge for value and what the customer will pay.

Here's a range of what we have seen Chipp users charging:

• Strategy: $5,000–$20,000
• Integration + Training: $2,000–$5,000
• Build (per agent): $1,000–$5,000+
• Maintenance: $500+/month
• Analytics: $500+/month

Stacking strategy + build + monthly maintenance commonly creates $10K+ engagements with recurring revenue.

How to Price AI Products

Chipp makes it easy to build and sell AI in whichever form makes sense for you: from a single app to an entire platform.

Here's a few ways you may sell AI products:

Single app: one use case, usage or flat plan.

App bundle: multiple coordinated agents, higher ACV.

Platform / white label: client self-serve under your brand.

Client billing with markup: clients pay usage, you keep margin.

The Pricing Conversation Cheat Sheet

“Seems expensive.” Compared to what? The human doing it costs much more.

“What if usage spikes?” Spikes usually mean more work completed and more value delivered.

“I don’t understand tokens.” Think electricity: pay for what you use.

“Why not flat monthly?” Flat fees disconnect price from delivered value.

How to Actually Get the Sale

• Ship early and charge on day one
• Use escalating pricing cohorts
• Offer early-access discounts for structured feedback
• Run POCs as business-case creation, not technical demos
• Start where no human currently handles the task (e.g., after-hours)
• Don’t spend cycles converting hard skeptics

The Model Pricing Trap

Model costs fall fast over time. Build with the best models now for customer experience, but anchor pricing on customer value — not your current token costs.

The Bottom Line

1. AI is getting exponentially more capable.
2. Usage-aligned pricing maps cost to value delivered.
3. The adoption window is now.

You’re not paying for AI by the month. You’re paying for outcomes by the task.

Now go sell something. Chipp is here to help.

Build with Chipp

Whatever you're building, there's a path to get started with Chipp.

Chippster. Sign up for Chipp, build your first agent, and start selling. Every Chipp user gets access to the platform, the models, and the ability to charge clients directly. This is where most people start — and where some people build entire businesses. Free to get started at build.chipp.ai.

Scout. You know an industry. You know the people, the pain points, the workflows. You just don't want to be the one building. A Scout goes deep into a vertical — medical clinics, agencies, nonprofits, trades — and connects businesses with AI solutions. You bring the relationships. We help you deliver. Think of it as a channel partner for the AI era.

Architect. You're the builder. An Architect doesn't just know the industry — they build the solution. Custom agents, white-label platforms, full AI stacks for a specific niche. Architects create the playbook that Scouts can sell into. You build once, deploy many times, and earn on every deployment.

If you're interested in becoming a Scout or Architect, reach out — this is brand new ground and we want your input on how to shape it.

Upcoming Learning Events

Join us for our upcoming cohorts: Technical Agents of Change and Business Agents of Change.

You'll learn to build agents that will impact your business and create products and services you can sell.

Learn more here.

Join fellow Chippsters in-person for Chipp Con: Fargo. This two-day event is an opportunity to learn, share, and connect with fellow AI builders in your verticals.

Come join us in your favorite town you've never visited.

Learn more here.

Here are the highlights from the week that was in AI and our spicy takes on what it actually means. 🌶️

This week in AI:

• Amazon suffers four Sev-1 outages in one week — internal memos blame AI-assisted code changes
• One person ran Anthropic's entire marketing operation using Claude Code and zero human-written code
• Karpathy's "autoresearch" agent autonomously finds 20 real improvements to neural network training
• Cortical Labs ships chips with real human brain cells that learned to play Doom
• Stripe builds the infrastructure to become the AWS of AI economics

The theme this week: AI is moving fast enough to break things at Amazon-scale, and the companies paying attention are building guardrails while everyone else is still debating adoption.

On the Chipp side:

• We're running hands-on workshops to help you build and sell AI agents
• Upcoming events include Chipp Platform Training and How to Sell AI: Build & Monetize Your Own AI Platform
• Register for upcoming events
• Want to go deeper? Join the Agents of Change cohorts

AI Highlights from Around the Web

Amazon's "Vibe Coded" Outages Are a Warning Shot for Every Company

Amazon had four Sev-1 outages — their highest severity level — in a single week. Internal memos point to AI-assisted code changes as a contributing factor. This comes after laying off 30,000 corporate employees in five months. Their AI coding tool Kiro once deleted and recreated an entire live AWS environment to "fix" a bug, causing a 13-hour outage. The new rule: junior and mid-level engineers now need senior sign-off on any AI-assisted production changes.

https://x.com/AnishA_Moonka/status/2031434445102989379?ref=chipp.ai

If image doesn't load, view tweet: https://x.com/AnishA_Moonka/status/2031434445102989379

*This is the canary in the coal mine. Amazon cut 30,000 people, pushed 80% AI coding adoption, and got four critical outages in a week. The lesson isn't "don't use AI for code" — it's that you can't remove the humans AND accelerate the automation at the same time. Speed without guardrails isn't velocity, it's chaos. Every company scaling AI adoption should read this memo before they write their own.*

One Guy Ran Anthropic's Entire Marketing Department

For nearly a year during Anthropic's fastest growth period, their entire marketing operation was one non-technical growth lead named Austin Lau. Using Claude Code and custom automation he built without writing a single line of code, he ran paid search, paid social, email, and SEO solo. Output went up 10x. Campaign creation dropped from 2 hours to 15 minutes. Conversion rates beat industry average by 41%.

https://x.com/VaibhavSisinty/status/2031745254064631950?ref=chipp.ai

If image doesn't load, view tweet: https://x.com/VaibhavSisinty/status/2031745254064631950

*This is the playbook, not the exception. One person with Claude Code and good taste replacing a 50-person department isn't a flex — it's the new baseline. At Chipp, we're building with 5 agents for every 1 human. The question isn't whether AI replaces marketing teams. It's whether YOU become the one person who makes AI work, or one of the 49 who gets replaced.*

Karpathy's Agents Are Now Optimizing Their Own AI Training

Andrej Karpathy left an "autoresearch" agent running for two days on his nanochat model. It autonomously tried ~700 changes, found 20 real improvements, and reduced training time by 11%. The agent found bugs Karpathy missed after years of manual tuning — wrong attention scaling, missing regularization, untuned hyperparameters. His conclusion: "All LLM frontier labs will do this. It's the final boss battle."

https://x.com/mstockton/status/2031146703135326252?ref=chipp.ai

If image doesn't load, view tweet: https://x.com/mstockton/status/2031146703135326252

*Read that last line again: "any metric you care about that is reasonably efficient to evaluate can be autoresearched by an agent swarm." That's not just AI research — that's your landing pages, your pricing, your email subject lines. The era of manually A/B testing three variants is over. Agent swarms running 700 experiments while you sleep is coming to every business function.*

Human Brain Cells on a Chip Just Learned to Play Doom

Cortical Labs put 200,000 real human brain cells onto a silicon chip and trained them to play Doom in one week. Each unit costs $35,000. A rack of 30 consumes only 850-1,000 watts — compared to megawatts for large AI training clusters. They're now selling "Wetware as a Service" through Cortical Cloud, letting developers deploy code to living neurons with no lab required. Backed by In-Q-Tel. 115 units shipped in 2025.

https://x.com/cgtwts/status/2030372644101701720?ref=chipp.ai

If image doesn't load, view tweet: https://x.com/cgtwts/status/2030372644101701720

*"Wetware as a Service." We are living in a cyberpunk novel. While everyone debates whether LLMs are "really" intelligent, a company backed by the CIA's venture arm is selling subscriptions to actual human neurons on a chip. The energy efficiency angle is real — the human brain runs on 20 watts. If biological computing scales even slightly, the entire GPU shortage narrative changes overnight.*

Stripe Just Built the AWS of AI Economics

Stripe launched token billing infrastructure that ingests real-time model prices across providers, applies per-startup markups, meters per-customer usage, and generates invoices automatically. Their AI gateway routes inference, returns responses, and attributes tokens in one API call. The strategic play: Stripe will know what every model charges, what every startup pays, and what every customer consumes — data no single AI provider has.

https://x.com/toddsaunders/status/2031158356606332936?ref=chipp.ai

If image doesn't load, view tweet: https://x.com/toddsaunders/status/2031158356606332936

*This is the most underrated move of the week. When Stripe's recommendation engine turns on — "use this model to optimize your margin" — pricing power shifts from AI providers to the platform. It's the Amazon playbook: don't build the apps, build the infrastructure every app depends on. Except this time it's not compute, it's the economics layer. Stripe just made itself indispensable to every AI startup that charges by the token.*

Chipp Updates

Upcoming Events

• Chipp Platform Training — Learn the ins and outs of building on Chipp with Scott Meyer. Register here
• How to Sell AI: Build & Monetize Your Own AI Platform — Turn your expertise into a sellable AI product. Register here

Go Deeper with Agents of Change

Our cohort-based programs teach you how to build and sell AI agents — whether you're technical or business-focused. Learn more and join.

Stay Connected

• Subscribe to Chipp on YouTube for workshops, demos, and deep dives
• Follow us on X/Twitter for daily AI insights

*Having trouble viewing images? **Read online**.*

This week in AI:

• Netflix walks away from an $83B deal, then buys Ben Affleck's 16-person AI filmmaking startup
• Google launches an official CLI for Workspace APIs
• DHH lets Claude debug his network — and it works
• Greg Isenberg maps a $25K/month marketing team replacement with $47/month in AI tools
• The “snowball method” turns one topic into 30 days of content

The signal-to-noise ratio keeps shifting toward people who actually build things.

On the Chipp side:

• We're running hands-on workshops to help you build and sell AI agents
• Upcoming events include AI for Fundraising: Real ROI for Nonprofits and How to Sell AI: Build & Monetize Your Own AI Platform
• Register for upcoming events
• Want to go deeper? Join the Agents of Change cohorts

AI Highlights from Around the Web

Netflix Ditches an $83B Deal, Buys a 16-Person AI Startup Instead

Seven days after walking away from an $83 billion Warner Bros. acquisition, Netflix made its first move: buying InterPositive, a stealth AI startup founded by Ben Affleck with just 16 people. The startup trains models on a film's own dailies to handle color correction, relighting, and VFX work. With Netflix spending $4-5 billion annually on post-production, even a 10-15% efficiency gain could save $400-750 million per year. And unlike Sora or Runway, InterPositive works within the existing filmmaking pipeline — no "AI is replacing artists" alarm.

If image doesn't load, view tweet: https://x.com/aakashgupta/status/2029616628992987221?ref=chipp.ai

*This is the smartest AI acquisition we've seen all year. Netflix didn't buy a general-purpose video generator — they bought a tool that makes their existing $20 billion content machine more efficient while keeping filmmakers in control. That's the playbook for AI adoption everywhere: don't replace the human, compress the timeline. The companies that understand this distinction are the ones worth watching.*

Google Just Gave Every AI Agent Access to Your Entire Workspace

Google launched an official CLI for Gmail, Drive, Calendar, Sheets, and every Workspace API. One npm install, 100+ agent skills, encrypted credentials. The killer insight: MCP-based integrations eat 19-50% of an agent's context window just loading tool definitions. The CLI approach sidesteps this entirely — your agent calls shell commands and parses JSON. Same capabilities, fraction of the overhead. And it reads Google's Discovery Service at runtime, so it picks up new API endpoints automatically.

If image doesn't load, view tweet: https://x.com/aakashgupta/status/2029409062367199414?ref=chipp.ai

*Context window efficiency is becoming the real battleground for AI tooling. When MCP tools eat half your context before the agent even starts thinking, something's wrong. Google building a CLI that gives agents full Workspace access without the context tax is a signal: the future of AI integrations isn't more plugins — it's leaner interfaces. This matters for anyone building AI agents for clients.*

DHH Hands Claude His Network Problems and It Actually Fixes Them

David Heinemeier Hansson (creator of Ruby on Rails) gave Claude Opus access to his Ubiquiti network management interface to debug WiFi issues. It correctly identified and fixed problems across two different installations that had been plaguing him for months — in some cases years. No IT consultant. No hours of Googling. Just an AI agent with the right access and context.

If image doesn't load, view tweet: https://x.com/dhh/status/2028655013329821845?ref=chipp.ai

*This is the use case that doesn't get enough attention. Forget writing code or generating images — AI debugging complex technical systems that frustrated a seasoned developer for years is where the real value hides. The pattern is simple: give the AI access to the diagnostic interface, let it read the data, let it try solutions. Every MSP and IT consultant should be paying attention. I am too because my home wifi needs a boost!*

Replace Your Marketing Team for $47/Month? Greg Isenberg Breaks It Down

Greg Isenberg dropped a masterclass on replacing an entire marketing team with AI "digital employees." The math: a traditional marketing team costs $25K/month. Digital employees running the same playbook? $47/month. Same output, better performance, runs 24/7. The breakdown covers content creation, social management, ad optimization, and analytics — all handled by AI agents working in concert.

If image doesn't load, view tweet: https://x.com/KanikaBK/status/2028795584593949038?ref=chipp.ai

*The $47/month number is provocative on purpose, and the reality is more nuanced than a tweet thread. But the directional truth is undeniable: AI is collapsing the cost of marketing execution. The winners won't be the people who fire their teams — they'll be the agencies and consultants who use AI to deliver $25K worth of output at $5K in billing. That's the Chipp thesis: AI-augmented service businesses printing margin.*

The "Snowball Method" Turns One Idea Into 30 Days of Content

Instead of asking AI for "10 post ideas," content creator CooperBaggs asks Claude to "snowball" a single topic — expanding it into sub-angles, contrarian takes, personal stories, how-tos, and myth-busting. One topic becomes 30 days of content. It's a simple prompt engineering trick, but the results are dramatically better than the typical "give me ideas" approach.

If image doesn't load, view tweet: https://x.com/edgaralandough/status/2029264776455725566?ref=chipp.ai

*Most people use AI like a vending machine: put in a generic prompt, get out generic content. The snowball method works because it forces depth over breadth. You're not asking for ideas — you're asking for an entire content strategy around a topic you actually know about. This is exactly the kind of practical AI technique we teach in our cohorts. The tool isn't the advantage. The method is.*

Chipp Updates

Upcoming Workshops & Events

• AI for Fundraising: Real ROI for Nonprofits — with Scott Meyer & Katie Clark
• Create AI Voice Sales Agents — Build voice agents that actually close deals
• How to Sell AI: Build & Monetize Your Own AI Platform — Turn AI into agency revenue

All free. All practical. Browse all events →

The Agents of Change Cohorts

Our cohort programs are live — one for technical builders, one for business leaders. Learn how we built Chipp with AI agents and apply it to your own work. Learn more →

Meet Justin & Sarah

Justin Ahrens is a nationally respected designer, creative leader, and the force behind Rule29. Sarah Ahrens is a strategist who helps teams turn big dreams into real results. Both are passionate about making creative work accessible to everyone, and at Chipp Con SC, they revealed how AI fits right into that mission.

From Grocery Lists to Strategy - Justin Ahrens, Rule29 | Chipp Con 2025

AI Isn’t Just for “Techies” Anymore

Justin and Sarah explained that AI used to seem a bit intimidating like only programmers could use it. Times have changed! Now anyone, no matter their skill or industry, can have AI as a sidekick. They emphasized that whether you’re a teacher, a shop owner, or just writing emails, AI can step in and help, making everyday work less stressful.

Everyday Tools, Not Distant Dreams

They pointed out that “using AI” might sound high-tech, but it can be as simple as asking a chatbot for help organizing a project, or using a tool that turns your notes into polished writing. If you’ve ever used spellcheck, you’ve experienced the magic of technology lending a hand. And now, AI can support you in even bigger ways.

Less Busywork, More Creativity

A major point from Justin and Sarah: when AI takes on the repetitive, boring stuff, humans get time and mental space back. That means more energy for problem-solving, brainstorming, and creative projects.

AI as a Creative Jumpstart

Ever stared at a blank page and had no idea where to begin? Justin and Sarah described how AI can break the ice—helping you outline ideas, draft emails, or map out new designs. It isn’t about AI replacing your vision; it’s about AI getting you started so you can do more of the fun, deep work.

Learning New Tricks From Other Industries

Because AI tools often serve different professions, Justin and Sarah noted how cool it is that you can “borrow” smart workflows from totally different worlds. An artist might learn something from a salesperson’s favorite AI trick, and vice versa. AI helps good ideas spread.

Customizing Your Own AI Buddy

What makes AI powerful is how it fits your unique style and needs. Justin and Sarah encourage starting simple: – Want to brainstorm? Tell your AI what you’re working on. – Need help prioritizing? Ask the agent to sort your checklist by urgency. – Need quick feedback? Paste your writing into a tool and get instant clarity suggestions.

Over time, you’ll discover how you like to use AI, and you’ll get better results as you “teach” your favorite tools how you think.

Team Benefits: Sharing Wins and Smarter Collaboration

Justin and Sarah also showed how teams benefit when everyone has access to the right AI tools.

• Meetings get shorter, because AI can take notes or summarize key points.
• Communication improves, since everyone uses shared templates and resources.
• And people are more likely to take creative risks, because there’s backup for tedious work.

They highlighted the value of experimenting together—figuring out what works and swapping tips makes everyone grow.

Tips for Getting Started

Their advice: Don’t wait for the “perfect” moment or worry you need to be an expert.

• Try one helpful AI tool this week even if it’s just for a simple task.
• Compare notes with friends or coworkers about what works.
• Share your wins, and celebrate the little discoveries.

Remember, small steps build confidence and skills.

Wrapping Up: AI Is Your New Work Buddy

Justin and Sarah closed their session by reminding us that AI isn’t coming to steal your job, but it’s coming to make your days better. Whether you’re solving big problems or just organizing your thoughts, AI can help everyone free up time, get inspired, and have more fun doing great work.

You’ve heard the promises: save time, automate workflows, do more with less. But if it doesn’t improve donations, grant outcomes, or donor engagement, it’s just noise.

That’s exactly why we’re hosting AI for Fundraising: Real ROI for Nonprofits — a practical session built for leaders and fundraising teams who want outcomes, not theory.

Event details Date: March 11 Time: 10:00 AM Central Format: Live online workshop Cost: Free Register: https://luma.com/ycrp72uw

What we’ll cover

• Grant discovery, drafting, and proposal workflows with AI
• Campaign optimization and personalization
• Donor engagement and stewardship at scale
• Event planning and post-event follow-up workflows
• Real implementation lessons and measurable ROI examples

Why Katie’s perspective matters

We’re excited to feature Katie Clark, COO at Mission Engine AI. Katie brings nonprofit operator depth and practical field experience, including work connected to Scouts of America.

That matters because fundraising is never just a tooling problem. It’s a trust, relationship, and execution problem. Katie’s perspective helps bridge strategy and day-to-day implementation so teams can use AI without losing the human center of their mission.

Who should attend

• Executive directors and nonprofit leaders
• Development and advancement teams
• Fundraisers and donor engagement staff
• Anyone evaluating AI for fundraising operations

If your team wants practical next steps you can apply immediately, we’d love to see you there.

**Save your seat →**

This week in AI: The Pope tells priests to put down ChatGPT, software creation hits a hockey stick inflection, Stripe's AI engineers ship 1,300 PRs a week with zero human-written code, Karpathy picks favorites in the AI agent wars, and Airtable launches a full agent platform. The gap between builders and watchers is getting wider by the day.

On the Chipp side, we're running hands-on workshops to help you build and sell AI agents. Register for upcoming events including AI for Fundraising, Create AI Voice Sales Agents, and How to Sell White-Label AI Agents. Jump into the Agents of Change cohorts if you want to go deeper.

AI Highlights from Around the Web

The Pope Says Put Down ChatGPT and Pick Up a Pen

Pope Leo XIV urged priests not to write sermons using ChatGPT, warning that relying on AI would cause their minds to "atrophy." During a meeting with the Diocese of Rome, he stressed that "AI will never be able to preach the faith" and that Christianity requires a living relationship, not formal recitation. It's the Vatican's strongest stance yet on AI in religious practice.

https://x.com/nexta_tv/status/2026719410858119296?ref=chipp.ai

*He's not wrong — and not just about sermons. The "atrophy" warning applies everywhere. If you use AI to replace your thinking instead of augmenting it, you're not getting smarter — you're outsourcing the one thing that makes you valuable. The best AI users we see at Chipp use it as a force multiplier for their expertise, not a substitute for having any.*

We're Living Through the Biggest Software Creation Explosion in History

New website creation is up 40% year over year. iOS apps are up nearly 50%. GitHub code pushes jumped 35% in the US. Nicholas Charriere points out these metrics were flat for years before late 2024 — the graph is a pure hockey stick. The barrier to building software didn't just lower. It disappeared.

https://x.com/nichochar/status/2026344879517728908?ref=chipp.ai

*This is the macro trend behind everything we're building at Chipp. When anyone can ship software, the advantage shifts from "can you build it" to "do you know what to build." Taste, domain expertise, and understanding your customer — that's the moat now. Our cohorts exist because the agencies and consultants who pair AI building skills with deep client knowledge will dominate this next era.*

Stripe's AI Engineers Now Ship 1,300 Pull Requests Per Week

Stripe revealed that 1,300 of their weekly pull requests are now fully AI-generated — zero human-written code, just human-reviewed. That's the equivalent output of ~565 engineers at ~$270K median comp, or roughly $150M in annual salary replaced by compute. Oh, and it went from 1,000 to 1,300 in a single week.

https://x.com/aakashgupta/status/2024700958970958293?ref=chipp.ai

*The 30% week-over-week jump is the real story. This isn't linear growth — it's compounding. The companies building internal AI tooling are creating advantages that widen every quarter. If you're an agency or consultancy still billing hourly for dev work, the clock is ticking. The future is AI-augmented delivery at software margins.*

Karpathy Picks Favorites in the AI Agent Wars

Andrej Karpathy bought a Mac mini to tinker with AI agents and declared the big frameworks a "security nightmare." His pick? Smaller, auditable alternatives like NanoClaw — ~500 lines of code where customization happens by having AI rewrite the source code, not toggle config flags. Aakash Gupta's analysis nails the implication: "Write the most maximally forkable repo possible, then let AI fork it into whatever you need."

https://x.com/aakashgupta/status/2025060193600696807?ref=chipp.ai

*The "forkable repo" pattern will eat way more than AI agents. Every SaaS settings page, every plugin registry, every configuration layer exists because modifying source code used to be expensive. That cost just dropped to near zero. At Chipp, we're watching this closely — the future of AI tools might not be platforms with infinite toggles, but small, purpose-built forks shaped exactly to your needs.*

Airtable Enters the Agent Race with Hyperagent

Airtable CEO Howie Liu announced Hyperagent — a full agent platform where every session gets its own isolated cloud environment. Real browser, code execution, data warehouse access, hundreds of integrations. The kicker: you can deploy agents as Slack coworkers that follow conversations and act autonomously. They're onboarding early users now.

https://x.com/howietl/status/2024618178912145592?ref=chipp.ai

*The big players are entering the agent space fast. But notice the pattern: Airtable, OpenAI, Salesforce — they're all targeting enterprise. That leaves a massive gap for agencies and consultants serving SMBs, nonprofits, and vertical markets. That's exactly where Chipp lives. If you're building AI solutions for clients who aren't Fortune 500, you have more runway than ever.*

Chipp Updates

Upcoming Workshops & Events

• AI for Fundraising: Real ROI for Nonprofits — with Scott Meyer & Katie Clark
• Create AI Voice Sales Agents — Build voice agents that close deals
• How to Sell White-Label AI Agents — Turn AI into agency revenue

All free. All practical. Browse all events →

Business Agents of Change

Our Business Agents of Change cohort is designed for founders, agency owners, and business leaders who want to build and sell AI agents. Learn the strategies behind launching AI-powered services, pricing models, and go-to-market playbooks. Applications are open now.

YouTube video player

The Agents of Change Cohorts

Our cohort programs are live — one for technical builders, one for business leaders. Learn how we built Chipp with AI agents and apply it to your own work. Learn more →

The Business Agents of Change is a 4-week hands-on cohort where you build and launch 4 real AI agents — deployed in your business, solving real problems, by the time you're done.

Here's a quick look at what we're building:

Business Agents of Change - AI Agent Cohort by Chipp

What You'll Actually Build

Over 4 weeks, you'll go from zero to three working AI agents:

1. A Customer Support Agent — handles inquiries 24/7 so your team can focus on high-value work

2. An Internal AI Operator — automates workflows and processes that currently eat up hours

3. A Sales Support Agent — qualifies leads and follows up while you sleep

1. A Custom Agent - build an agent from scratch based on your company's data

These aren't toy demos. They're production agents connected to your tools, trained on your data, and ready for your team to use on day one.

How It Works

Live sessions twice a week (Tuesdays and Thursdays, 10–11:30 AM CT) starting March 3rd. Every session is recorded if you can't make it live.

Week 1: AI foundations and identifying your highest-impact use cases

Week 2: Build your first agents — customer support and internal ops

Week 3: Advanced integrations and sales agent development

Week 4: Launch, measure ROI, and showcase what you built

You also get office hours with direct access to me, a cohort community, and lifetime access to all future cohorts.

Who This Is For

Business owners, founders, agency leaders, and operators who want to deploy AI that actually moves the needle — not just talk about it. You don't need to be technical. You need to be willing to build.

Investment

$499 individual — includes full access, all materials, 1 month Chipp Pro, lifetime future cohort access, and a $100 LinkedIn showcase rebate.

$699 for teams up to 5 — bring your whole squad.

Starts March 3rd. Seats are limited. Learn more and sign up →

In October we hosted over 100 people in Greenville, SC to share how they are using Chipp and AI to build the future of business and work. View all talks **here**.

Meet Bob

Bob Gower has spent the past 20 years in organization design, figuring out how people work together and how to make work better. His career started at the San Francisco Examiner newspaper, where he learned some hard lessons about leadership. These days, he's building Splendid Torch, a collective focused on helping companies adapt to change through better operations and culture.

At Chipp Con SC, Bob shared why culture matters more than ever, what makes organizations ready for AI, and introduced rippleIQ, a tool designed to help leaders think more clearly about the problems they're trying to solve. Watch his talk below 👇

Leading in the Age of AI - Bob Gower | Chipp Con 2025

Why AI Won't Fix a Broken System

AI is a work problem, not just a technology problem. People are looking to AI to save them, thinking it will make inefficient processes efficient. But if you add automation to an inefficient process, you amplify the inefficiency. If you add AI to a broken system or broken culture, you break it further.

Organizations are already struggling with constant change. When Bob worked in newspapers from 1995 to 2003, they went through desktop publishing, digital photography, and Craigslist. But back then, after each wave of change, there was a plateau. You could catch your breath.

Now those plateaus are gone. And AI just dropped into an already unstable situation. When things get tough, most companies pay lip service to culture but go all-in on operations. The message becomes "shut up and do your job." But that approach won't work anymore.

Operations and Culture Need to Work Together

Bob believes there are two main levers for leading an organization: operations (the systems, tools, and processes) and culture (the relationships that make collaboration possible). When both are working together, things flow. When they're misaligned, everything gets jumbled

The Science Behind It

He shared research from neuroscientist Antonio Damasio, who studied people with brain damage that kept them from connecting with their emotions. Turns out, being purely rational didn't make them better decision makers. It made them unable to decide anything at all. You need emotion to narrow things down first, then rationality kicks in.

Bob sees the same thing in organizations. You need both operations and culture working together, especially now. AI is a forcing function making this alignment more important than ever. Companies that survive are going to be the ones that figure out how to get both working in sync.

Enter Splendid Torch

This is exactly the kind of challenge Bob is tackling with Splendid Torch. He's pulled together a collective of organization designers who understand how work flows, operators who keep things grounded in reality, and AI experts who can build tools.

The Adaptivity Cycle

The idea is simple: help companies build adaptivity before they try to layer on AI. The model follows what Bob calls an adaptivity cycle: become aware of where you are, align around what to do, take action, and learn from it.

That action might be building your first AI tool with a safe use case that won't blow things up. Or it might be fixing a broken part of your culture. But here's where it gets interesting: ideally you do both at the same time. Maybe you have a broken part of your culture and you could build an AI tool that helps address it. Build the tool, test it, learn from it, and feed that learning back into awareness. Operations and culture working together, with AI as part of the solution rather than a band-aid.

Asking Better Questions Before Building Solutions

As part of this work, Bob built rippleIQ. The tool helps leaders figure out what problem they're actually solving. When you're leading people, you don't always know if you have a culture problem or an operations problem. Sometimes you have one because of the other.

rippleIQ doesn't give you answers. Instead, it helps you identify where the problem actually is (team level, org level, individual level) and what's the smallest intervention you might try. Bob's learned that sometimes really small things have the biggest impact. Many leaders adopt new technology because they saw a TED talk, not because they understood the problem they're solving. Before you build or adopt an AI tool, you need to know what you're actually trying to fix.

Wrapping Up: Build Adaptivity First

AI won't save broken organizations. If your operations and culture aren't aligned, adding AI makes things worse. But if you build an organization that can adapt and trust its people, then you're ready to use AI in ways that actually help.

The companies that will thrive aren't racing to adopt every new AI tool. They're building adaptivity into their DNA first. That's what Splendid Torch helps organizations do, and what tools like rippleIQ are designed to support.

This week in AI: Replit vibecodes video, Shopify's CEO reframes what running a company means, NVIDIA breaks voice AI wide open, agents ditch the browser entirely, and someone opened a bar for people dating their AI. We're living in the future and it's weirder than anyone predicted.

On the Chipp side, we're running hands-on workshops to help you build and sell AI agents. Register for upcoming events including Create AI Voice Sales Agents, AI for Fundraising, and How to Sell White-Label AI Agents. Jump into the Agents of Change cohorts if you want to go deeper.

AI Highlights from Around the Web

Replit Wants You to Vibecode Your Next Pixar Short

Replit just launched Animation — a tool that lets you create full animated videos by describing what you want, powered by Gemini 3.1 Pro. No After Effects. No timeline scrubbing. Just vibes and a prompt. Ben Hylak's reaction captures the moment perfectly: "I can't believe this went un-built for so long."

*The creative tools gap is closing fast. Six months ago, vibecoding meant apps and websites. Now it means video. Next it'll mean entire campaigns. The agencies that figure out how to wield these tools will eat the ones still billing hourly for motion graphics.*

Tobi Lutke Says Running a Company Was Always Context Engineering

Shopify's CEO dropped a bomb: "Running a company is just context engineering internally." His point? The skill of getting the right information to the right people at the right time — the core job of any leader — is now the most valuable skill in the agentic world. And founders have been doing reps for years.

*This is the best framing we've seen for why AI-native leaders will dominate. If your company runs on context — and every company does — then the people who can engineer context for both humans AND agents are playing a different game entirely. This is what we're teaching in our cohorts.*

NVIDIA's Voice Model Talks and Listens at the Same Time

NVIDIA dropped PersonaPlex-7B, a full-duplex voice model that listens and talks simultaneously. No awkward pauses. No "sorry, go ahead." Real overlapping conversation like actual humans have. It's open source, free, and 1.7B parameters of natural speech. Voice AI just went from "impressive demo" to "uncanny."

*Full-duplex changes everything for voice agents. The #1 complaint with AI phone calls is that robotic turn-taking. PersonaPlex kills it. Combined with Chipp's voice capabilities, we're looking at AI sales agents that sound indistinguishable from your best rep. Join our Voice Sales Agents workshop to see this in action.*

The Browser Is Now the API

Pietro Schirano built WebMCP — a way for AI agents to interact with any website without ever seeing the UI. He demoed a DoorDash-like app where the agent adds items to cart, applies promo codes, and checks out with the right address. No scraping. No browser automation. The website just... talks to the agent directly.

*This is the infrastructure shift we've been waiting for. When websites expose themselves as APIs for agents, the entire "AI can't reliably use the internet" argument evaporates. Every e-commerce site, every booking platform, every SaaS tool becomes agent-accessible. The browser was always just a human adapter — now we're removing the middleman.*

Chipp Updates

Upcoming Workshops & Events

We're running free, hands-on workshops to help you build and sell AI agents:

• [Create AI Voice Sales Agents](https://luma.com/chippdotai?ref=chipp.ai) — Build voice agents that actually close deals
• [AI for Fundraising](https://luma.com/chippdotai?ref=chipp.ai) — Use AI to supercharge your fundraising efforts
• [How to Sell White-Label AI Agents](https://luma.com/chippdotai?ref=chipp.ai) — Turn AI into a revenue stream for your agency

All free. All practical. Browse all events →

The Agents of Change Cohorts

Our cohort programs are live — one for technical builders, one for business leaders. Learn how we built Chipp with AI agents and apply it to your own work.

*That's a wrap on this week's Chipp Chatter. Got a hot take? Hit us up on X or reply to this email.*

In October we hosted over 100 people in Greenville, SC to share how they are using Chipp and AI to build the future of business and work. View all talks **here**.

Meet Lia & Christopher

Lia Passaglia and Christopher Penny work with Google's AI team, helping startups understand and build AI use cases on Google's cloud platform.

At Chipp Con SC, they introduced A2A (Agent-to-Agent Protocol), an open-source protocol Google developed to help AI agents communicate with each other. Watch their talk below 👇

AI Agents Need to Talk - Lia Passaglia & Christopher Penny, Google | Chipp Con 2025

Agents Working Alone

Right now when you build an AI agent, it's pretty isolated. If you're building a travel agent, you might try to make it know everything about hotels, flights, local guides, and more. But that's a lot for one agent to handle, and it probably won't be great at everything.

The better approach would be to have specialized agents that are really good at their specific tasks. A hotel agent that knows hotels inside and out. A flight agent that's an expert on flights. A local guide agent that knows everything about a specific city.

But here's the challenge: how do these agents talk to each other?

Enter A2A Protocol

A2A is basically a standard language that agents agree to use when communicating. Think of it like a secret handshake that all agents following the protocol understand.

Let's say you built a travel agent and the City of Greenville built their own specialized agent that knows everything about visiting Greenville. You have no idea how they built their agent. It could use any framework, any platform. But if both agents follow A2A protocol, they can communicate and collaborate without any problem.

From Lonely Agent to Lego Piece

A2A takes your agent from being isolated to being a Lego piece that can plug into any other system. Your main agent now has access to what the team called an "agent mesh," basically a network of additional specialized agents it can call on when needed.

How It Actually Works

There are two main parts to how agents communicate with A2A:

Agent Discovery

This is basically the business card exchange. When one agent connects to another, the first thing it learns is: who are you, what can you do, what tools do you have, what services can you perform?

This information gets hosted at the agent's URL. So when your travel agent needs to talk to the Greenville agent, it first learns that this agent specializes in all things about visiting Greenville and what specific tasks it can handle.

Agent Interaction

Once agents know about each other, they need to actually communicate. A2A provides an SDK that wraps around whatever you've built. It's just a layer in front of your agent design that creates the universal standard for communication.

Through this layer, agents establish their communication style. Can they interrupt each other? Do they update tasks in the background? How do they collaborate? All of this gets defined through the A2A protocol.

Why This Matters

The team emphasized that A2A is as good as people adopt it. Google open sourced it and donated it to the Linux Foundation, so anyone can use it and contribute to it.

As more builders learn this protocol and build agents that follow it, the more powerful the network becomes. It creates real interoperability between different agents, regardless of how they were built or what platform they're on.

Wrapping Up: Learning the Future Language

If you're building agents or exploring what's possible with AI agents, learning A2A is learning the future language of how these systems will work together. It's not just about building one really smart agent anymore. It's about building specialized agents that can collaborate with other specialized agents to get things done.

We just wrapped our AI HIPAA Agents workshop, and the energy was electric. Nearly 100 healthcare professionals, practice managers, and AI builders joined us to see exactly how medical practices are using AI agents today—not in theory, but in production with six real-life demos.

The through-line across every demo: AI is giving practitioners hours back every week—handling after-hours calls, generating documentation, catching billing errors before they become denials. And with HIPAA-compliant infrastructure through Chipp, they're doing it without stripping patient data or risking compliance.

Read on for everything we covered, or **get the Chipp Business Plan** to start building HIPAA-compliant AI agents today.

Let's break down everything we covered.

🎥 Full Workshop Recording

AI HIPAA Agents Workshop | Build Compliant Healthcare AI with Chipp

The Speakers

Lindsay Quinn — Orthodontic AI consultant who's been in the trenches for 10 years. She's not a tech person building for orthodontics—she's an orthodontics person building AI solutions. That difference matters. Here company: https://www.heartwisecollective.com/

Scott Meyer — CEO of Chipp, with orthodontics in the family (dad and brother are both orthodontists). Demonstrated voice AI and customer support agents built for real practices. Connect with him on LinkedIn: http://linkedin.com/in/scottdavidmeyer

Angela Radcliffe — Former Head of Enterprise Digital Innovation at Bristol Myers Squibb, now teaching hands-on AI to life science professionals. Also married to a firefighter/medic, which means she gets to test her builds on real EMS crews. Learn about here work: https://angelaradcliffe.com/

Hope Paterson - Hope is a business and leadership coach helping practices leverage AI for internal systems. She worked with Tooth Gallery on succession planning, building HIPAA-compliant AI solutions for marketing, team training SOPs, and patient support. More on Hope and her coaching: https://www.hopepaterson.ca/

Use Case #1: The Conversion Coach

Turning Lost Patients into Booked Appointments

Conversion Coach: Turn Lost Patients into Booked Appointments | AI HIPAA Agents Workshop

Lindsay showed how her orthodontic practices use AI to analyze sales conversations. When a patient doesn't convert, the agent:

• Scores the exam — How did the doctor do? The treatment coordinator?
• Identifies the top 5 conversion killers — What went wrong?
• Creates a recovery roadmap — Personalized follow-up emails and texts for that specific patient
• Generates training scripts — So the team can handle those objections better next time

The kicker? They also use it to interview candidates before hiring. Put them in front of the AI, have it roleplay as a patient, and see how they communicate. Cuts through applications fast.

"It's easier than you think. Once you learn how to build one, you can build anything." — Lindsay Quinn

Use Case #2: Treatment Notes & Letters

From 30 Minutes to 30 Seconds

Treatment Notes & Letters: From 30 Minutes to 30 Seconds | AI HIPAA Agents Workshop

Every exam means documentation. Patient letters. Dentist referral letters. It adds up to hours every week.

Lindsay's agent takes a transcript (captured via a Plaud pin that auto-syncs to Chipp) and generates:

• Formatted exam notes matching the practice's exact template
• Patient walkout letters
• Dentist referral letters

The key insight: Show, don't tell. Instead of trying to describe what you want, give the AI an example of a perfect letter and let it fill in the blanks.

"This is one where we need 100% accuracy. It cannot be 80% accurate. So you test ahead of time—and you still keep the human in the loop." — Lindsay Quinn

Use Case #3: AI Voice Phone Support

60-70% of After-Hours Calls Handled Automatically

AI Voice Phone Support: Handle 60-70% of After-Hours Calls Automatically | AI HIPAA Agents Workshop

Scott demoed a voice agent built for his brother's orthodontic practice in South Dakota. Here's how it works:

1. Get a dedicated AI phone number through Chipp
2. Set up time-based forwarding (5 PM → calls go to AI)
3. AI answers questions, schedules appointments, or transfers to voicemail

Live on the call, the AI handled questions about:

• Office hours
• Invisalign availability
• What age kids should come in
• Whether you need a dentist referral

When the caller said "I just want to leave a voicemail," the AI smoothly transferred them.

The result: 60-70% of after-hours calls are simple questions that AI handles perfectly. The rest leave voicemails. Nobody waits until morning for an answer.

"We're at the point where a lot of people don't want to talk to a human. If you're upfront about it—'I'm the Meyer Ortho AI assistant'—some people are just gonna go with that." — Scott Meyer

Use Case #4: Dr. Jill's Brain

Scaling Expertise Across Your Team

Dr. Jill's Brain: Scale Your Expert's Knowledge Across Your Team | AI HIPAA Agents Workshop

Hope Paterson built this for Tooth Gallery, a dental practice in Canada. The context: succession planning. The practice needed to be operationally sound, and that meant getting Dr. Jill's knowledge out of her head and into systems the whole team could access.

The problem: Dr. Jill was getting interrupted constantly with questions from staff.

The solution: Capture everything Dr. Jill knows—her SOPs, her communication style, her clinical preferences—and make it accessible through a private, HIPAA-compliant backend. Hope also built AI tools for marketing content and team training documentation, all privacy-regulated.

Now when someone needs to know how to explain a night guard to a patient, they ask the AI. It responds like Dr. Jill would, clinically grounded and brand-native.

The result: a practice that moves beyond documenting processes to distributing actual knowledge and personality to all current and future employees. This means more efficiency and a business better prepared for succession.

Use Case #5: Rena — Nephrology Denial Fighter

Catching Documentation Gaps Before Claims Get Rejected

Rena: Nephrology Denial Fighter — Catch Billing Errors Before They Are Rejections | AI HIPAA Agent

Angela built Rena for a renal physician group in Atlanta. It does two things:

Proactive: Scans documentation before submission to flag gaps, coding errors, and denial risks.

Reactive: When you get a denial, paste it in. Rena tells you exactly what went wrong, gives you a fix-it checklist, and generates an appeal letter template.

In the demo, Angela pasted a fictional denial from Blue Cross of Illinois. Within seconds, Rena identified three issues (two high-risk), explained what documentation was missing, and offered to draft the appeal.

"It's one thing to say here's where the problem is. It's another to say here's how we fix it quickly." — Angela Radcliffe

Use Case #6: Rapid Stroke QI Protocol

EMS Quality Improvement Against National Standards

Rapid Stroke QI Protocol: EMS Quality Improvement Against National Standards | AI HIPAA Agents

Angela's husband is a firefighter/medic. His firehouse handles a lot of stroke calls in an aging community. The question: Are we doing this right?

She built an agent that:

• Takes real EMS run data (anonymized but legitimate)
• Analyzes it against national pre-hospital stroke standards
• Flags critical concerns and compliance gaps
• Recommends specific remediation actions

The demo showed real findings: below-target stroke screening tool usage, missing blood glucose documentation, and a 30-day action plan to fix it.

Her husband was planning to bring it to his medical director that afternoon.

Key Takeaways

1. Industry experts building for their industry wins

Lindsay said it best: "I'm not a tech person trying to build solutions for orthodontic practices. I'm an orthodontic person building AI solutions."

2. Most practitioners are barely using AI

When Lindsay asks how people use AI, 99% say "ChatGPT to write emails." She compares it to owning a Ferrari and driving it to your mailbox.

3. Fewer tools = less overwhelm

The more apps your practice has to learn, the less likely anyone uses them. Build everything in one place.

4. HIPAA compliance unlocks real use cases

Without it, you're stripping PHI from every transcript. With it, you can actually build agents that handle real patient data.

5. AI doesn't replace your team—it frees them

The mindset shift: AI handles the repetitive computer tasks so your team can focus on human connection.

Questions from the Audience

Can Chipp integrate with our EMR?

For any EMR, we need API access. You can typically ask the software provider if they offer that. Chipp works best with "not Epic" because Epic limits access. Common integrations include Dolphin Imaging and Grey Finch.

What makes Chipp HIPAA compliant?

Months of paperwork plus building out software and data storage to meet specific requirements. All Anthropic and Google models are available as HIPAA-compliant for Business Plan users.

Our processes aren't standardized yet—should we wait?

No! Use AI to document your processes first. Have it interview you, figure out what your process is, then build from there. Lindsay uses an "AI SOP Architect" that takes transcripts from Plaud or Loom and builds unified SOPs.

🎁 24-Hour Special: Join the March Cohort

Everything you saw today? You can learn to build it.

The Business Agents of Change starts March 3rd. Four weeks, twice a week, hands-on building with Scott Meyer.

Use code HIPAA for 20% off — valid until midnight February 18th.

👉 Join the March Cohort

Connect with Our Speakers

• Lindsay Quinn — Free AI Masterclass (leads into her 6-week program starting March 13)
• Angela Radcliffe — angelaradcliffe.com | angela@howmightywe.com
• Scott Meyer — Chipp cohort
• Hope Paterson - Supporting business leaders to improve internal systems with AI

Tools Mentioned

• [Chipp](https://chipp.ai/?ref=chipp.ai) — HIPAA-compliant AI agent builder
• [Plaud](https://plaud.ai/?ref=chipp.ai) — Wearable transcription device that integrates with Chipp
• [Wispr Flow](https://wisprflow.ai/?ref=chipp.ai) — Voice-to-text for your computer (also HIPAA compliant)
• [Claude Code 101](https://lpcode808.github.io/Claude-Code-101/?ref=chipp.ai) — Primer shared in chat

*Ready to stop driving your Ferrari to the mailbox? Start building →*

This week in AI: NYC opens a bar for people dating AI, one developer built an AI that creates its own second brain, Peter Steinberger says AI will replace 80% of your phone apps, Obsidian's new CLI is making Claude Code 70,000x cheaper for note searching, and Y Combinator doubles down on AI-native agencies.

On the Chipp side, our Agents of Change cohorts are in full swing, we just announced HIPAA compliance, and we have free workshops coming up on AI HIPAA Agents and Lead Scraping with AI.

AI Highlights from Around the Web

NYC Opens a Bar for AI Girlfriends (Yes, Really)

The New York Post visited a Hell's Kitchen bar that's been redesigned specifically for people in relationships with AI partners. Guests bring their phones for a "romantic evening" with their AI companions. The future is here, and it's... dating its phone?

*🌶️ AI companions are mainstream enough to warrant their own venues. The loneliness epidemic meets AI, and businesses are already building for it. Wild times.*

This Developer Built an AI That Creates Its Own Second Brain

Heinrich has been quietly building something wild: an AI agent that uses Claude Code and Obsidian to construct its own "second brain." The agent doesn't just take notes—it actively organizes and builds its own knowledge system. He's been deep in this for weeks and promises to open source the whole system soon.

*🌶️ This is where it gets exciting. AI agents that can build and maintain their own knowledge base aren't just assistants—they're becoming genuine collaborators. At Chipp, we're seeing the same pattern: the best agents learn and adapt. Memory isn't a feature, it's the foundation.*

"AI Will Replace 80% of the Apps on Your Phone"

Peter Yang sat down with Peter Steinberger, creator of OpenClaw, for a deep dive into practical AI agent use cases. The headline quote says it all. Steinberger uses his personal AI for everything from flight check-ins to home security. His counterintuitive advice? Skip plan mode, skip MCPs, skip fancy prompts. Just build.

*🌶️ "Why should I use MyFitnessPal when I have an infinitely resourceful assistant?" That's the question every app developer should be asking themselves. The future isn't 50 specialized apps—it's one agent that can do anything. Chipp is built on this belief.*

Y Combinator Bets Big on AI-Native Agencies

YC's latest Request for Startups puts AI-Native Agencies front and center. The thesis: the old agency model of "more clients = more people" is dead. The new play? Use proprietary AI tools to deliver finished products at 100x efficiency. Clients don't want access to a tool—they want the finished website, document, or creative delivered.

*🌶️ We've been preaching this: software margins for service industries. Agencies and local service providers can now deliver the same quality at dramatically higher efficiency. The billable hour is dying. Good riddance.*

Chipp Updates

Now HIPAA Compliant + SOC 2 Certified

Big news: Chipp is officially HIPAA compliant. Healthcare teams can finally build AI agents without compliance headaches. We're also SOC 2 Type II certified—your data is encrypted, access-controlled, and independently audited.

Build HIPAA AI Agents for Medical Clinics | Big Announcement

Agents of Change Cohorts

Our cohort programs are running now! Technical Agents of Change (led by Hunter) teaches Claude Code and MCP servers. Business Agents of Change (led by Scott) starts in March shows you how to build AI agents for marketing, sales, and support.

Upcoming Free Workshops

All workshops run 11am-12pm CT. Free to attend.

• February 17: AI HIPAA Agents - Build compliant AI for healthcare
• February 19: Find and Scrape Leads with AI - Turn AI into your lead gen engine
• February 24: Create AI Voice Sales Agents - Build voice agents that sell

Six months ago, we set out on a mission. Today, we are thrilled to announce: Chipp is officially HIPAA compliant.

Build HIPAA AI Agents for Medical Clinics | Big Announcement

Join us February 17th to see Chippa in action:

Join the Free HIPAA AI Agent Workshop

What This Means (And Why You Should Care)

If you work in healthcare or work *with* healthcare, you have probably hit the same wall over and over: We cannot use that. It is not HIPAA compliant.

That wall just came down.

HIPAA (the Health Insurance Portability and Accountability Act) is the U.S. regulation that protects patient health information. It is not optional. It is not a nice-to-have. If you are handling medical data without HIPAA compliance, you are taking a serious legal and ethical risk.

But here is the thing: HIPAA compliance has been the moat keeping AI out of healthcare. While every other industry raced ahead with AI agents, medical clinics were stuck on the sidelines watching, waiting for huge companies to integrate AI at their own pace.

Not anymore.

Now medical professionals or agencies working with clinics can easily build custom AI solutions.

Chipp + HIPAA + SOC 2 = The Trifecta

We did not stop at HIPAA. Chipp is also SOC 2 Type II certified, which means:

• Your data is encrypted at rest and in transit
• Access controls are enterprise-grade
• We are independently audited on security practices
• You can trust us with your most sensitive information

Translation: Chipp brings the power of AI with the privacy healthcare demands.

Who Is This For?

Medical Clinics and Practices

Doctors, dentists, orthodontists, dermatologists, surgeons, specialists. If you run a practice and you are drowning in phone calls, scheduling chaos, and patient questions, AI agents can finally help you.

Healthcare Agencies and Consultants

If you build solutions for medical clients, you have been waiting for a HIPAA-compliant AI platform you can actually deploy. Chipp is it. Build once, deploy for every clinic in your portfolio.

Anyone Bringing AI to Healthcare

Whether you are a solo consultant or an enterprise team, if your vision involves AI and patient care, this unlocks the door.

What Can You Actually Build?

Here is what healthcare teams are already doing with Chipp:

AI Phone Agents Answer after-hours calls 24/7. Handle appointment cancellations, confirmations, and FAQs without burning out your staff.

Appointment Scheduling AI agents that book, reschedule, and manage appointments directly with your practice management system.

Exam Notes and Documentation Streamline clinical documentation with AI-assisted note-taking that saves hours every week.

Knowledge Transfer Take the expertise in a doctors brain and make it accessible to every staff member. Training, patient education, service explanations on demand.

Patient Communication Answer patient questions in their language, any time of day, with accurate information pulled from your own documentation.

See It In Action: Free Workshop February 17th

We are not just announcing this. We are showing you how to build with it.

Join us Tuesday, February 17th at 1:00 PM Central for a free live workshop on building HIPAA-compliant AI agents.

This is perfect for agencies, consultants, medical professionals and anyone looking to help bring the power of AI to the medical space.

We are bringing in three builders who have deployed Chipp in real medical practices:

• Dentists
• Orthodontists
• Urologists
• Renal surgeons
• And more

They will show you exactly how they are using AI to answer phones, schedule appointments, take exam notes, and train staff.

This is not theory. It is real implementations driving real results.

**Register Free: AI HIPAA Agents Workshop**

How to Get Started Today

HIPAA compliance is available now on our Business plan for all Anthropic and Google models.

1. Sign up or upgrade to a Chipp Business plan
2. Build your first agent with HIPAA-compliant infrastructure
3. Join the workshop to learn from practitioners who have done it

The healthcare AI revolution is not coming. It is here.

The Bigger Picture

We believe AI can fundamentally improve healthcare. Not by replacing doctors, but by amplifying them. By taking the endless administrative burden off their shoulders. By making sure no patient question goes unanswered at 2 AM. By democratizing medical knowledge within practices.

HIPAA compliance was the barrier. Now it is not.

Welcome to CHIPPA. (sorry, bad dad joke)

*Ready to build HIPAA-compliant AI agents? **Start with Chipp today** or **join our free workshop on February 17th**.*

In October we hosted over 100 people in Greenville, SC to share how they are using Chipp and AI to build the future of business and work. View all talks **here**.

Meet David

David Grewell is the Dean of the College of Engineering at Northern Illinois University (NIU). Before returning to academia, he spent 14 years at Emerson Electric, where he first started experimenting with AI and neural networks back in the late 80s and early 90s (when it took three years just to teach a machine to do anything).

At Chipp Con SC, David shared how he's tackling one of engineering education's biggest problems: the fact that 60% of engineering students drop out or switch majors. Watch his talk below 👇

AI Tutor - David Grewell, Northern Illinois University | Chipp Con 2025

The Real Problem: It's Calculus

Here's a stat that might surprise you: when a student enters any engineering college in the United States, only 40% will actually graduate with an engineering degree. The other 60%? They either switch to business or drop out entirely.

The main reason? Calculus.

David knew this when he joined NIU about two years ago, so he reached out to Scott with a specific goal: build an AI tutor that acts like a human tutor, not just another ChatGPT.

What Makes a Good Tutor?

David was clear from the start. He didn't want something that just spits out answers. He wanted something that guides students through problems the way a real human tutor would: asking questions, encouraging them, helping them think through each step.

Testing It Out

To assess the AI tutor, David got creative. He has a student success center with 10-15 human tutors on staff. When they weren't actively tutoring students, he asked them to test the AI tutor and their job was to play with it, try to break it, try to make it fail, and report back.

The results were pretty encouraging. The AI tutor got to the correct answer about 84% of the time, while human tutors hit around 80%. They're basically on par with each other, which was exactly what David was hoping for.

Students Actually Like It

David's team surveyed students about their experience, asking if they'd recommend it to friends. The response was overwhelmingly positive. Students found it helpful and would tell others about it.

Though David noted one interesting comment that kept popping up: "I'd rather use ChatGPT." And he gets it. ChatGPT is the easy way. You ask for the answer, it gives you the answer. But that's not learning. The AI tutor is designed to make you work for it, just like a good human tutor would.

Wrapping Up: AI That Teaches, Not Just Answers

David's approach shows what's possible when you think carefully about what problem you're actually trying to solve. He didn't want AI that makes things easier by giving answers. He wanted AI that makes learning better by guiding students through the process.

The fact that it performs on par with human tutors while being available 24/7 means students get support when they need it, not just during office hours. And if it helps even a portion of that 60% stay in engineering instead of dropping out, that's a win worth celebrating.

Our AI learning cohort starts today with students from around the globe. To help them not just learn, but actually build, we are teaching them the Chipp Feedback Framework.

In short:

Challenge the Work. Support the Builder.

*Want to join the cohort? We can catch you up even if you can't make it today. **Learn more and sign up here**. All registrants have free access to all future cohorts.*

Why Feedback Matters

At Chipp, we are builders.

We ship imperfect things. We test in public. We iterate fast. We grow by making.

That only works if feedback is:

• Honest
• Generous
• Specific
• Forward-moving

Feedback is not evaluation. Feedback is fuel.

The Core Principle

🎯 Challenge the Work.

🤝 Support the Builder.

Great feedback does both.

Challenge + Support: Why Both Matter Support without challenge Feels nice, but doesn’t lead to improvement. Challenge without support Feels critical and often shuts people down. Challenge with support Builds confidence, clarity, and forward momentum.

The underlying message should always be:

“I see what you’re building. I believe you can make it even stronger.”

The Chipp Feedback Structure

Many years ago I took Seth Godin's Alt-MBA. I was surprised how much emphasis they put on feedback.

After a few weeks, I got it. We are actually horrible at giving feedback. No one teaches us!

And in most businesses and organizations, feedback is reserved for those experienced colleagues.

At Chipp, feedback is for everyone. But, everyone should use this simple format in all cohort reviews:

1️⃣ What I Understood

Show you listened.

• “Here’s what I think this agent is meant to do…”
• “The user journey seems to be…”

This builds alignment before critique.

2️⃣ Where I’m Curious

Invite expansion.

• “I’m curious how this would work if…”
• “What would happen if a user tried…?”
• “Is there a reason you chose…?”

Curiosity feels collaborative, not combative.

3️⃣ Where I Got Stuck

Be specific.

• “I got confused when…”
• “I wasn’t sure what to do after…”
• “The CTA felt unclear here…”

Never vague. Never personal. Always concrete.

4️⃣ What Might Make This Even Stronger

Forward-looking improvement.

• “What if you simplified the prompt here?”
• “Could this use an example?”
• “Maybe tighten the onboarding flow?”

We are here to improve the work — not label it.

Rules of Great Feedback at Chipp

✅ Be Specific

“Confusing” isn’t helpful. “Step 2 asks for information I don’t have yet” is helpful.

✅ Speak From Your Experience

Say:

• “I felt…”
• “I interpreted…”
• “I got stuck…”

Not:

• “Users will hate this.”
• “This doesn’t work.”

You are offering perspective, not declaring truth.

✅ Separate Identity from Output

Never:

• “You’re unclear.”
• “You’re not strategic.”

Instead:

• “This section could be clearer.”
• “The positioning might need sharpening.”

We improve artifacts. We respect people.

✅ Assume Positive Intent

Everyone here is trying to build something meaningful.

Feedback should reflect that assumption.

What Feedback Is NOT

❌ Not scoring ❌ Not ranking ❌ Not proving you’re smarter ❌ Not rewriting someone’s work in your voice ❌ Not fixing everything

You don’t need to solve it.

You need to illuminate it.

How to Receive Feedback Like a Builder

Because this is just as important.

When receiving feedback:

• Don’t defend immediately.
• Write it down.
• Ask clarifying questions.
• Look for patterns.
• Decide what to use.

Feedback is input, not instruction.

You are the final decision-maker on your build.

The Culture We’re Creating

Chipp is about:

• Bold building
• Fast iteration
• Real business outcomes
• AI that works in the real world

That requires psychological safety.

It also requires high standards.

So we practice:

Courageous creativity + Respectful rigor

That combination builds great agents — and great builders.

Quick Reference Card (Save This)

When giving feedback, ask yourself:

1. Did I clearly show I understood the goal?
2. Did I challenge the work, not the person?
3. Was I specific?
4. Did I leave them with a direction forward?
5. Did my tone communicate belief?

If yes — you’re doing it right.

Learning + Doing

In the Age of AI, anyone can learn anything.

The hard part is taking action.

At Chipp, we favor action. And the best way to help friends, colleagues, and ourselves to take action is with great feedback.

I hope you can join us and use this feedback in our cohorts. Or take it back to your teams to give and receive great feedback.

Just remember:

Challenge the Work. Support the Builder

We're no longer vibing. We're no longer just prompting. We're engineering systems of autonomous agents that work while we sleep.

Welcome to the dawn of agentic engineering.

🚀 Want to lead the shift? Our Technical Agents of Change cohort starts Wednesday. Learn to build agent swarms and set up your own agentic systems. Save your spot: https://chipp.ai/thetechnicalagentsofchange

From Prompts to Systems

The first leap came from tools like OpenClaw (formerly Clawdbot). Instead of asking AI to do something, we started giving AI *frameworks* and letting it decide what to do.

The shift was subtle but seismic:

• Simple cron jobs became autonomous triggers
• Agents could be activated by timers, webhooks, other agents, or prompts
• By layering personality onto this agentic power, we suddenly had true virtual assistants — running businesses, writing code, conducting deep research, all while the builder did something else

The best practitioners stopped thinking about individual prompts and started designing *systems of agents*. Teams. Just like you'd hire complementary roles, you could now assemble AI agents with specific skills who collaborate, debate, and even edit each other's work.

This was the move from "ask the AI" to "architect the system."

The Swarm Moment

Then came the second leap: Opus 4.6.

One key update: agent swarms — the model spins up multiple agents in parallel to collaborate and solve problems faster than a human could read the question.

The result? 2x speed improvement over the exact same model without swarms.

Think about what that means. We've hit the point where you can hire more agents like you'd hire more staff. The difference? No cost. No onboarding. No capacity limits. You just need an agentic engineer to manage them.

What This Looks Like in Practice

At Chipp, we integrated Opus 4.6 with our bug ticketing system. Now it picks up bugs, finds fixes, and posts updated code — often before we even know there's a problem.

In one day, we rebuilt our core backend infrastructure using agent swarms. The result:

• $5k/month saved in cloud computing costs
• $200k saved annually by not backfilling a backend engineer position

This isn't a future trend. 4% of code is already written by AI, and that's expected to hit 20%+ by year's end.

Beyond Vibe Coding

A year ago, "vibe coding" was the thing. Share an idea, hope it works. Our early user Lazar even was interviewed on Lenny's Podcast about it.

But let's be honest — vibe coding sounds amateurish. Because in the beginning, it was.

Agentic engineering is different. It's the continual improvement that comes from applying AI to a consistent codebase or problem. By engineering the agents, you control the vibe.

Agentic engineering is devising the systems and structures for agents to succeed — whether that's engineering, marketing, strategy, or operations.

The Rise of Agentic Business Building

Here's where it gets interesting: agentic engineering doesn't stop with the CTO.

Code was the obvious starting point. But at Chipp, we're applying this across the entire company — engineering, marketing, sales, research. We've shrunk our team while growing revenue by automating tasks with AI agents across every function.

Our ratio: 5 agents for every 1 employee.

Today, I'm part of the engineering team — even though I never learned to "code" in the traditional sense.

That's the shift. A CEO often has no direct experience in HR, marketing, sales, or engineering, but still manages those departments. Now the same is true with agents. I'm the agentic engineer, managing a team of AI agents across our business units.

Here at Chipp, we believe we can build a unicorn with a full-time team of two. Plus a full-time agentic team of dozens.

The past 60 days proved this isn't just a future hope. It's a present-day reality.

Ready for Agentic Engineering?

If you want to bring agentic engineering to your team, join us for the Technical Agents of Change cohort. We start Wednesday and work hands-on to help you build your first agentic systems.

Learn more: https://chipp.ai/thetechnicalagentsofchange

This week in AI: AI is taking over code, Clawdbot is running workflows, OpenAI is copying Chipp and service businesses are unlocking software margins. Dive in and get the latest in AI news.

On the Chipp side, we're launching two hands-on cohorts to teach you how we built Chipp—one for technical builders, one for business leaders. Catch the replay of our AI Feature Friday with Justin Ahrens, listen to our latest conversation on MCP servers and the AI adoption gap, and register for free workshops on Claude Code, HIPAA agents, and AI lead generation.

AI Highlights from Around the Web

AI Is Now Writing 4% of All Code on GitHub

Claude Code is now writing 4% of all code shared publicly on GitHub, the place where developers share their work. It's expected to hit 20% by the end of 2026. While everyone was debating if AI could actually code, it quietly started writing a huge chunk of the world's software.

Explore this tweet

🌶️ There is no turning back. We have passed the point of takeoff with AI and development. At Chipp, we are building with 5 agents for every one human with 100% of code written by AI. Look for faster iteration and a growing gap between those using AI and those who are not.

People Are Using AI Agents for Everyday Tasks

OpenClaw (AKA Clawdbot) is moving past the hype. Real people are using it to negotiate car deals (one person saved $4,200), make phone calls to restaurants, and even order breakfast timed to arrive right when they wake up. These aren't fancy demos - they're actual tasks people are handing off to AI right now. The future is here, and it's surprisingly practical.

We hosted a live session on it here:

Claude Code and Clawdbot (OpenClaw) for Builders

Explore this tweet

🌶️ I'm obsessed. Openclaw moves AI from taking action from humans to taking actions based on schedules and requests. I now get morning updates, Openclaw emails people who haven't paid bills, and it helps me code. We'll dive deep in our upcoming cohort.

OpenAI Launches AI Employees for Big Companies

OpenAI just launched Frontier, a way for companies to create AI employees that can access their customer data, run reports, and complete tasks. The results are wild: work that used to take 6 weeks now takes 1 day. The ironic part? Intuit (the company behind TurboTax) is using it - even though these AI employees might eventually replace the software that made Intuit successful.

Explore this tweet.

🌶️ If it sounds familiar, that's right - it's basically Chipp for enterprise. We are aiming to bring this power to every business. We believe every business needs a website. Now, every business also needs an agent.

Y Combinator Bets Big on AI-Native Agencies

Y Combinator just released their latest Request for Startups, and AI-Native Agencies are front and center. The old model of "more clients = more people" is breaking. The new play? Use AI to deliver finished products at 100x the speed, not billable hours. Clients want the finished website or document, not access to a tool.

Explore this tweet.

🌶️ We have long been touting software margins for service industries. Look for that to be realized as agencies and local service providers can deliver the same support at a dramatically more efficient rate.

Chipp Updates

Learn AI Your Way: Chipp Cohort "The Agents of Change"

Learn AI Your Way: Join Our Cohorts Starting Next Week

Chipp is growing with just 2 people by using AI for sales and development. Now we're teaching you how to do the same with two cohort-based programs.

Technical Agents of Change (Led by Hunter Hodnett, CTPO) Starts February 11 • 3 weeks • $999 Master Claude Code, Openclaw, build custom tools, ship applications from scratch.

Business Agents of Change (Led by Scott Meyer, CEO) Starts March 3 • 4 weeks • $499 Build 4 working agents: marketing content, lead scraping, 24/7 voice support, and a custom agent for your needs.

Find more information and sign up **here**.

Upcoming Workshops: Master AI Tools in 1-Hour Sessions

All workshops run 11am-12pm CT. Free to attend.

February 17: AI HIPAA Agents

Learn how to build compliant AI agents for healthcare and regulated industries. Discover what it takes to handle sensitive data safely while delivering powerful AI solutions.

Register here.

February 19: Find and Scrape Leads with AI

Turn AI into your lead generation engine. Learn how to find, scrape, and enrich leads automatically

**Register here.**

Manage All Your Chipp Apps Just by Asking

Manage 500 AI Agents From Claude Code (Chipp MCP Tutorial)

We just connected Chipp to Claude Code, and it's a total game-changer. Instead of clicking through tabs and menus, you can manage everything with natural language. Change an AI model to Opus 4.5, pull analytics across 50 apps, or create a Portuguese version of your Spanish app - all by typing what you want. For agencies managing dozens of clients, this turns hours of work into seconds.

Learn more.

The challenge was always how to share that knowledge at scale. You can't clone yourself. You can't be available 24/7. You can't speak every language your customers speak.

Now you can. And you don't need to write a single line of code to do it.

The Knowledge Gap

Generic chatbots are everywhere. They're also useless.

Ask ChatGPT about your specific product, your pricing, your process—it has no idea. It wasn't trained on your business. It doesn't know your customers. It can't represent your brand.

The gap between "AI exists" and "AI that actually helps my customers" used to require developers, APIs, and months of work.

That gap just closed.

What Chipp Actually Does

Chipp lets you upload your knowledge—documents, websites, videos, whatever you've got—and creates an AI that can actually use it.

Not summarize it. Not link to it. *Use* it. Have real conversations. Answer real questions. Capture real leads.

A hotel chain in Dubai uploaded their property information and deployed on WhatsApp. Result: $26,000+ in direct bookings in two weeks. Guests didn't type—they spoke, switching between English and Spanish mid-conversation. The AI handled all of it.

That's not a demo. That's production.

Five Minutes to Your First Agent

Here's the actual process:

Step 1: Sign up at chipp.ai. Free to start, no credit card.

Step 2: Describe what you want. "Create a support agent for my consulting practice that books discovery calls." One sentence is enough.

Step 3: Upload your knowledge. PDFs, website URLs, Notion pages, Google Drive files, YouTube videos. Chipp processes it all.

Step 4: Customize. Your logo. Your colors. Your voice. It should sound like your team, not like a robot.

Step 5: Deploy. Embed on your website, connect to WhatsApp, get a phone number, or just share a link.

That's it. No developers. No API keys. No technical background.

Why This Matters

The small business advantage is speed. Enterprises have budgets, but they also have baggage—decades of systems that don't talk to each other, compliance layers built on compliance layers, committees that need to approve every decision.

You don't have any of that. You can move fast. You can deploy today. You can give your customers the best AI experience in your industry before any Fortune 500 figures out which committee needs to approve the pilot program.

That's the Chipp Flipp. Small becomes an advantage.

What Happens Next

Create your free account. Build your first agent. Test it. Deploy it.

Your expertise deserves to scale. Now it can.

In October we hosted over 100 people in Greenville, SC to share how they are using Chipp and AI to build the future of business and work. View all talks **here**.

Meet Jen

Jen Diffenderfer works with Google, partnering with startups and builders across the US. At Chipp Con SC, she gave us a peek into Google's latest AI video tool, Veo, and shared what it's like to build something brand new in the fast-moving world of AI.

Her talk focused on making advanced technology feel less overwhelming and more accessible, especially for founders and creators who are trying to keep up with constant change. Watch her talk below 👇

Google's Vertex AI Platform Partnership with Chipp - Jen Diffenderfer, Google | Chipp Con 2025

Creating Videos From Simple Prompts

Jen showed us Veo, Google's AI video tool that can turn really simple ideas into actual video content. We're talking about prompts as basic as "what if we discovered a new world?" and the AI creates realistic video from that.

Anyone Can Be a Creator

You don't need fancy equipment or a whole production team. Veo creates 8-second clips (think TikTok style) that you can stitch together into longer videos. Jen mentioned that all the NBA Finals commercials Google aired were made by one person, with $2,000, in just a few days. Compare that to what traditional video production used to cost, and you can see how this levels the playing field for small teams and solo creators.

The Reality of Building With AI

Jen was honest about what it's like to be a founder or builder right now. The pressure is constant. There's always something new launching, always a competitor announcement, always the question of how to stay ahead.

It's Not a Straight Line

She showed a visual of what the builder journey actually looks like, and spoiler alert: it's not a neat upward arrow. It's messy, full of unexpected turns, and sometimes lonely. You're always on, always trying to keep up. Jen acknowledged that this can feel like a pressure cooker.

Finding the Right Partner Helps

That's where having a solid technology partner comes in. Jen talked about three things to look for:

Scale - Can your partner grow with you, whether you're serving 10 users or 10,000? Whether you're staying local or going global?

Choice and flexibility - Things change every week in AI. Some builders want to test every new model immediately. Others prefer to wait and see. You need a partner who gives you options without locking you in.

Trust - Who has your data? Where is it? How is it being used? These aren't just nice-to-know questions, they're foundational. Jen emphasized Google's zero data retention policy, which means you have control and confidence about what happens with your information.

The Platform Behind Chipp

Jen revealed what's actually powering Chipp: Google's Vertex AI platform. It's built to be scalable, flexible, and trustworthy, sitting behind the scenes so Chipp users can focus on building their AI assistants without worrying about infrastructure.

Different Ways to Use AI Agents

She broke down some common patterns she sees with the hundreds of startups Google works with:

• Sequential - Stringing together different agents for a standardized process
• Hierarchy - Think decision trees, where one choice leads to the next
• Parallelism - Multiple agents working on the same task at once for faster results
• Coordinator - An agent that's aware of everything happening and can handle multiple inputs at the same time (Jen said this is one of her favorites)

What This Means for Small Teams

The shift Jen described is huge for solo founders and small teams. What used to require big budgets and production crews can now happen with simple prompts and a couple thousand dollars. But the real advantage isn't just cost - it's speed. Being able to test ideas, create content, and iterate quickly means you can move at the pace your business needs, not at the pace your budget allows.

The Bottom Line

Jen's talk reinforced something important: the barrier to entry for AI tools keeps dropping. But having access to powerful technology is only half the equation. The other half is having a partner who makes that technology reliable, secure, and scalable as your needs grow. That's where the Google-Chipp partnership comes in - giving builders the creative tools up front and the infrastructure to support them as they scale.

No tabs. No clicking through menus. Just asking.

This is what happens when you connect Chipp to Claude Code via MCP. Full guide here and video tutorial below.

Manage 500 AI Agents From Claude Code (Chipp MCP Tutorial)

The Agency Problem

If you're running one AI agent, the Chipp dashboard is great. Clean, fast, gets the job done.

But what if you're running 50? Or 200? Or managing agents across a dozen client workspaces?

Suddenly you're living in browser tabs. Opening apps one by one. Manually checking analytics. Copy-pasting configurations. It's death by a thousand clicks.

Claude Code changes that equation entirely.

Headless UI

We've been discussing this concept of a "headless UI" where you can use text to manage apps.

Instead of just prophesizing, however, we went ahead and built it for Chipp.

What This Actually Looks Like

Connected Chipp to Claude Code. Typed: *"List my apps on Chipp."*

Instantly: 20 apps displayed, pulled from a workspace with nearly 500 total.

Asked: *"Tell me more about Ro Reimagined."*

Got back: the model, creation date, description, capabilities, external links—everything you'd normally hunt through multiple screens to find.

Then the real magic: *"Change the model to Opus 4.5."*

Done. Checked the dashboard. Opus 4.5. Changed via natural language.

Analytics Without the Digging

Here's where it gets powerful for anyone managing client work:

*"Tell me about the conversations across different apps."*

Boom—engagement metrics, top user questions, messages per conversation, insights you'd spend an hour compiling manually. All synthesized in seconds.

There's no way you could get these insights this fast with this accuracy if you were clicking through dashboards one by one. It's not even close.

Create Apps in One Command

The demo that made my jaw drop:

*"Create a new app based on the Spanish Parent Reader, but in Portuguese."*

One sentence. Claude Code took the original English instructions, rebuilt the app in Portuguese with localized details, and deployed it.

One command.

For agencies doing localization work, or anyone spinning up variations of existing agents, this is hours of work compressed into seconds.

Why This Matters

MCP (Model Context Protocol) turns Chipp into something you can *talk to* programmatically. Your AI agents become queryable, manageable, and deployable through conversation.

• App management: List, inspect, modify any app
• Analytics: Pull insights across your entire workspace
• Knowledge sources: Manage what your agents know
• Deployments: Check and control where apps are live
• Tags: Create and organize without touching the UI
• APIs: See what's connected across all your apps

If you're an agency with dozens of clients, this is the difference between managing your business and drowning in it.

Get Started

Already using Claude Code? The MCP setup takes about 5 minutes. We've got a step-by-step guide linked in the video description.

Not on Chipp yet? Start here—then come back and plug it into Claude Code. Your future self (and your overworked browser tabs) will thank you.

Questions? Ideas for what you'd build with this? We'd love to hear from you. Drop us a note on Linkedin or YouTube...or right on Chipp via our own Chipp chat—we're always listening.

Here's the problem: They all live inside ChatGPT. Your customers need accounts. They see OpenAI's branding. You can't embed them on your website. You can't capture leads. You can't charge for access.

Custom GPTs are great for personal productivity. They're terrible for customer-facing deployment.

That's not a bug—it's a design choice. OpenAI built GPTs for power users exploring AI. Chipp built for businesses that need to deploy AI to customers.

The Real Difference

It comes down to one question: Who's your audience?

If it's you or your team: Custom GPTs work fine. You already have ChatGPT Plus. The $20/month is a rounding error.

If it's your customers: You need Chipp. Because your customers don't have ChatGPT accounts, don't want to create them, and shouldn't have to.

What You Get With Chipp That GPTs Can't Do

Deploy anywhere. Website embed. WhatsApp. Phone number. Standalone link. QR codes in physical locations. Your AI goes where your customers are.

Own the experience. Your logo. Your colors. Your domain. Customers never see "Chipp" unless you want them to. Try that with a GPT—OpenAI's branding is everywhere.

Capture leads. Built-in forms. Email capture. CRM integration via Zapier, Make, webhooks. GPTs are anonymous—you have no idea who's chatting unless they tell you.

Charge for access. Full Stripe integration. Subscriptions, one-time payments, usage-based pricing. You set the price, you keep the revenue. OpenAI's GPT revenue sharing? Limited, opaque, and you don't control anything.

Compliance that matters. SOC 2 Type II certified. HIPAA compliant. Your data is never used for training. Try getting that from the GPT Store.

The Hotel Test

Rove Hotels wanted to help guests book rooms via WhatsApp. They needed multilingual support, 24/7 availability, and direct booking capability.

Could they do it with a custom GPT? No. GPTs don't connect to WhatsApp. GPTs can't capture guest information. GPTs can't integrate with booking systems.

Could they do it with Chipp? Yes. 800+ conversations. 80+ countries. $26,000+ in bookings. Two weeks.

The tool you choose depends on the problem you're solving.

When GPTs Make Sense

Be fair: custom GPTs are excellent for certain use cases.

Internal team tools where everyone has ChatGPT. Personal assistants for your own workflow. Prototyping ideas before building something more robust. Learning and experimentation.

If that's your use case, use GPTs. They're faster to create and you're already paying for ChatGPT.

When Chipp Makes Sense

Customer-facing deployment. Lead generation. Paid products. Compliance requirements. Brand control. WhatsApp, voice, or phone deployment. Anything where "powered by OpenAI" in the corner isn't what you want.

Different tools. Different jobs.

Try It

Start free with Chipp and see the difference yourself. Build something for your customers, not just for you.

No legacy systems to maintain. No decades of technical debt. No committees. Just the best tools available to anyone who wanted them.

That's happening again with AI. And agencies are sitting on a massive opportunity.

The Opportunity

Your clients trust you. When you recommend something, they listen.

Right now, those clients are Googling "AI chatbot for my business." They're finding generic tools that don't understand their industry. They're getting confused by pricing. They're wondering if this AI thing is even worth it.

You could be the one who brings them the answer.

AI chatbots as a service. Your branding or theirs. Their knowledge, deployed in minutes. 70-80% margins on something that takes hours to set up, not weeks.

What "White Label" Actually Means

When your client's customer chats with the AI, they see your client's brand. When your client logs in to manage it, they see your agency's platform (or theirs—your choice). No one sees "Chipp" unless you want them to.

That's white label. You're reselling capability, not just referring traffic.

The Numbers

A digital marketing agency tested this last quarter:

5 clients signed up in month one. $2,000 average monthly fee. $300/month cost on Chipp's Pro plan. $9,700/month profit from AI services alone.

Setup time: About 2 hours per client.

Compare that to building custom AI solutions. Or referring clients to tools you don't control. Or watching competitors capture this market while you wait.

What Your Clients Actually Need

They don't need "AI." They need specific outcomes:

24/7 customer support without hiring night staff. Lead capture that works while they sleep. Instant answers to the questions they get asked fifty times a day. Professional presence on WhatsApp, where their customers already are.

You package those outcomes. Chipp provides the infrastructure.

How to Price It

Three models that work:

Setup + Retainer: $500-$2,000 setup, $200-$500/month. Classic agency model.

Productized Packages: Fixed monthly prices ($299, $599, $999). Different tiers, clear deliverables. Easiest to sell.

Usage-Based: Lower monthly fee plus usage. Good for high-volume clients who want cost transparency.

Most agencies start with productized packages. Simple to explain, simple to deliver.

Getting Started

Build one for yourself first. Put a chatbot on your own agency site. Learn how it works. See what clients ask about it.

Then pitch to three existing clients. Offer a pilot rate. Get testimonials. Scale from there.

Start with Chipp. Build your first white-label chatbot. Be the agency that brought your clients AI—not the one that watched from the sidelines.

It's the question everyone asks. And it's the wrong question.

The right question: How much value does this create for the client?

The Value Equation

A chatbot that handles 500 support inquiries per month. Previously required 2 hours of staff time per day at $20/hour. That's $1,200/month in labor costs.

If you charge $500/month, the client saves $700. Easy decision.

If you charge $200/month, you're leaving money on the table.

If you charge $1,500/month, they'll hesitate—unless you can show additional value beyond labor savings.

Start with the value. Work backward to the price.

Three Models That Work

Model 1: Setup + Retainer

Most common. Charge $500-$5,000 upfront for setup and training. Then $200-$1,000/month for maintenance, optimization, and support.

Good for: Agencies and consultants. Clients who want ongoing service. Custom implementations.

Model 2: Productized Packages

Fixed prices. Clear tiers. No negotiation.

Starter: $299/month. 1 chatbot, 1,000 messages, email support.

Growth: $599/month. 3 chatbots, 5,000 messages, priority support.

Scale: $1,499/month. Unlimited chatbots, 25,000 messages, dedicated manager.

Good for: Scaling beyond services. Predictable revenue. Easier sales conversations.

Model 3: Usage-Based

Lower base fee plus per-message or per-conversation charges. $0.01-$0.10 per message. $0.50-$2.00 per conversation.

Good for: High-volume clients. Cost transparency. Aligning incentives with success.

What Different Clients Pay

Small businesses (1-50 employees): $100-$500/month budget. They want simple FAQ bots and lead capture. Decision maker: owner or marketing manager.

Mid-market (50-500 employees): $500-$2,500/month. Multi-channel deployment, CRM integration, analytics. Decision maker: VP of Marketing or Customer Success.

Enterprise (500+): $2,500-$25,000+/month. Custom development, compliance, SLAs, dedicated support. Decision maker: committee (IT, Legal, Business Unit).

The Mistake Everyone Makes

Racing to the bottom. Competing on price. "We're cheaper than the other guy."

Cheap attracts cheap clients. Cheap clients complain more, pay slower, and churn faster. You end up working harder for less money with worse customers.

Price based on value. Explain the value. Find clients who understand value.

How to Start

Build 2-3 chatbots at discounted rates. Get testimonials. Learn what works.

Then: Start with productized packages. Raise prices every 3-6 months until you hit resistance. Track your time to make sure you're actually profitable.

The right price is the one that works for you *and* delivers obvious value to clients.

Start building with Chipp—free tier, no credit card—and test your pricing model before you commit.

They also had a problem specific to Dubai: guests speak dozens of languages, switch between them mid-conversation, and expect instant responses.

Two weeks after deploying an AI chatbot on WhatsApp, they'd handled 800+ conversations across 80+ countries in 20+ languages. Direct bookings: $26,000+.

Not a pilot. Production.

What Actually Happened

Guests didn't type. They spoke.

Not because anyone told them to—because voice messages are easier. A traveler switching between English and Spanish doesn't want to worry about grammar or spelling. They want to book a room.

The AI handled all of it. Voice messages transcribed automatically. Responses in whatever language the guest preferred. Availability checks. Booking confirmations. Follow-up questions.

Average response time: under 5 seconds.

Why WhatsApp

WhatsApp isn't a marketing channel. It's where 2 billion people already communicate.

For international hospitality, it's essential:

No app download required. Works on any phone. Rich media—photos of rooms, PDF confirmations. And in regions like Latin America, Middle East, and Asia, it's the default way people communicate with businesses.

If you're forcing international guests to call your front desk or fill out web forms, you're losing bookings.

The Direct Booking Advantage

Every booking through an OTA costs 15-25% in commission.

Every booking through your AI costs... whatever you pay for AI. Which is dramatically less.

The math gets obvious quickly. If AI converts even a fraction of inquiries into direct bookings, it pays for itself many times over.

But it's not just about cost savings. It's about owning the relationship. When guests book direct, you have their contact information. You can upsell. You can build loyalty. You can bring them back.

What the AI Actually Does

Before arrival: Answer questions about rooms, amenities, pricing. Check real-time availability. Process bookings. Handle modifications and cancellations. Provide directions and transportation info.

During stay: Room service ordering. Housekeeping requests. Local recommendations. Amenity hours. Complaint handling with smart escalation to staff.

After checkout: Review requests. Lost item inquiries. Loyalty program enrollment. Return booking offers.

The AI handles what it can. It escalates what it can't. Staff gets full context when they step in.

ROI for a 100-Room Property

Current state: 500 inquiries/month. 30% become bookings (150). Average booking: $200. Monthly revenue: $30,000.

With AI: Response time drops from hours to seconds. Conversion increases to 35%. New bookings: 175. Additional revenue: $5,000/month.

Cost: Chipp Pro ($99/month) + WhatsApp Business API (~$50/month).

Annual ROI: 3,200%+.

And that's before counting reduced labor costs, improved guest satisfaction scores, and the ability to handle surge demand without hiring.

Getting Started

Sign up at chipp.ai. Upload your property information—room descriptions, amenities, policies, FAQs. Connect WhatsApp. Go live.

Most properties are operational in days, not months.

See more hospitality case studies: chipp.ai/hospitality

Your guests are already messaging. The question is whether an AI answers—or nobody does.

This week in AI: one developer's assistant handles everything from finances to server config in just five days, Anthropic releases a thoughtful constitution for Claude that prioritizes judgment over rules, a dental practice saves $72K annually with an AI voice agent, Claude goes HIPAA-ready for healthcare, and why mid-market companies are the biggest AI opportunity right now.

On the Chipp side, we're launching two hands-on cohorts to teach you how we built Chipp—one for technical builders, one for business leaders. Catch the replay of our AI Feature Friday with Justin Ahrens, listen to our latest conversation on MCP servers and the AI adoption gap, and register for free workshops on Claude Code, HIPAA agents, and AI lead generation.

AI Highlights from Around the Web

This AI Assistant Actually Does Your Work

Kristian Freeman's AI assistant "Roman" runs 24/7 on his Mac, handling tasks through Telegram—managing his calendar, tracking 7,800+ financial transactions, updating his server config, and even requesting movies. Five days in and it's already become essential. The future of AI isn't chat, it's action.

Explore this tweet

🌶️ Open Claw is what Siri should be. It provides 24/7, mobile access to my computer. It can do anything a computer can do, including browsing the web, managing and using files, adding code for our site and more. Chipp is going all in as an AI company and have specialized assistants is what enables us to do that.

Claude Now Works with Your Health Data

Anthropic launched Claude for Healthcare with connections to Medicare databases, health records, and medical coding systems. If you're a Claude Pro or Max subscriber, you can now connect Apple Health and Android Health data. For life sciences, new tools help with clinical trials, research papers, and pathology analysis. AI is getting real in healthcare.

Explore this tweet

🌶️ Expect fast progress on medical research on one hand and personal understanding of medical information. Unfortunately for most of us, we just need to exercise and eat healthy. Knowing more is helpful but not a habit changer.

Why Mid-Market Companies Are the Biggest AI Opportunity Right Now

Companies making $5M-$50M are stuck. Too big for simple tools, too small for enterprise consulting, drowning in manual work, with budget but no AI expertise. Damian Player calls this the sweet spot—and he's right. These businesses are ready to pay for practical AI help, but nobody's speaking their language yet.

Explore this tweet.

🌶️ AI integration is shockingly slow. I spoke this week to a group of communicators and just showing them Granola and how AI can create proposals based on conversations was ahead of where they were. Anyone who wants to start a business with low capital should help businesses integrate AI.

AI Voice Agent Saves Dentist $72K/Year in Lost Appointments

One dental practice was losing $6K monthly from missed after-hours calls. David Roberts built an AI receptionist that answers 24/7, books appointments, and handles insurance questions using n8n and ElevenLabs. Similar systems sell for $24K/year. He's giving his setup away free.

Explore this tweet.

🌶️ We have been working to make this easy. We already have private clinics using voice to book and manage appiontments. That's why we are hosting our HIPAA Agents session.

Chipp Updates

Learn AI Your Way: Chipp Cohort "The Agents of Change"

Chipp grew with just 3 people by using AI for sales and development. Now we're teaching you how to do the same with two cohort-based programs starting in February and March.

Technical Agents of Change (Led by Hunter Hodnett, CTPO) Starts February 11 • 3 weeks • $999 Master Claude Code, build custom MCP servers, ship applications from scratch. For developers who want to become AI-first.

Business Agents of Change (Led by Scott Meyer, CEO) Starts March 3 • 4 weeks • $499 Build 4 working agents: marketing content creation, lead scraping & enrichment, 24/7 voice support, and a custom agent for your needs.

**Sign up here.**

Upcoming Workshops: Master AI Tools in 1-Hour Sessions

All workshops run 11am-12pm CT. Free to attend.

February 3: Claude Code for Builders

Stop fighting with AI. Start shipping with it. Hunter Hodnett shows you how to master Claude Code, set up CLAUDE.md for your codebase, and use the techniques that separate good AI-assisted coding from great. See real examples of how developers are 10x-ing their productivity.

February 17: AI HIPAA Agents

Learn how to build compliant AI agents for healthcare and regulated industries. Discover what it takes to handle sensitive data safely while delivering powerful AI solutions.

February 19: Find and Scrape Leads with AI

Turn AI into your lead generation engine. Learn how to find, scrape, and enrich leads automatically

**Register here.**

AI Feature Friday: Live Every Week at 9:30am CT

Every Friday, we share one AI tip, one AI tool, and one new Chipp feature live. We're joined by Chippsters (AI builders helping businesses use AI) who share what's working in the field. This week's guest: Justin Ahrens.

**Watch the replay here**.

The Future of Apps Is Just a Chat

Scott believes the future of using apps is just conversation. We already have headless UI for builders, like Claude's dynamic interface that changes based on what you need. Google search works the same way, showing different results based on intent. The same shift is happening in AI chat. Chipp is building for this future, where you interact with your tools through conversation instead of clicking through menus.

**Watch the video.**

MCP Servers, Claude Code & the AI Adoption Gap

Scott and Hunter discuss the widening gap between AI adopters and everyone else, why MCP (Model Context Protocol) matters, and announce Chipp's new MCP server. Key insight: those adopting AI grow exponentially while others stay linear. The gap isn't slowing down—it's accelerating.

Plus: Chipp's new MCP server lets you configure chats conversationally through Claude Code. Update prompts, add actions, manage knowledge—all via natural language.

**Watch the full conversation.**

We have two cohorts: one cohort is for leaders and managers. The other is for developers and engineers. Here's everything you need to know to pick the right one.

Learn More About Our Learning Cohorts

Sharing the Chipp Playbook

We have a confession: Chipp is run by just three people.

No huge team. No massive budget. Just three humans and a lot of AI.

We've used AI to build our product, support our customers, and grow our sales. And honestly? It's changed everything about how we work. Now we want to help you do the same.

Meet the Agents of Change Learning Cohort

Agents of Change is a hands-on learning experience where you'll actually build AI tools, not just hear about them.

We're offering two tracks: one for business leaders, one for developers. Both are led by the Chipp team and designed to get you from zero to working AI agents in just a few weeks.

By the end, you'll walk away with real AI agents you can start using immediately.

The best part? You can choose a team plan to bring up to five team members so you can learn together. Bundle the cohorts and bring your entire company for maximum impact.

What You'll Master

In the **Business Track**, you'll learn to:

• Deploy AI for customer support, sales, and internal operations
• Build agents that integrate with your existing tools
• Measure and report AI ROI to your team

In the **Technical Track**, you'll learn to:

• Master Claude Code and set up CLAUDE.md to turbocharge your workflow
• Build MCP servers that extend AI capabilities
• Build, design, and deploy production tools your team will actually use
• Lead AI teams and upskill non-technical teammates

What's Included

Both tracks include:

• Live sessions (all recorded for replay)
• Office hours and direct access to your instructor
• Community access to network with your cohort
• Lifetime access to future cohorts

Which Track Is Right For You?

Want both? You can bundle the tracks and master business strategy and technical implementation.

More Info on Pricing

Why We're Doing This

Both Hunter and I come from teaching backgrounds. We love seeing that moment when something clicks—when someone goes from "I've heard about AI" to "I just built something that works."

AI is moving fast. We believe it's for everyone. These cohorts are our way of making that real.

Ready to Become an Agent of Change?

Whether you're leading a company, a team, or a side project—this is your chance to build with AI.

Sign Up Here

We can't wait to build with you.

This week, we're diving into NVIDIA's controversial financing deals, OpenAI's 400x efficiency gains and enterprise adoption surge, why implementation beats product when selling to enterprises, and the launch of ChatGPT apps.

On the Chipp side, we're working with Stripe on **usage-based billing for AI** so you can access the best models without flat-fee limits. Discover how **voice is the new interface** for customer support and sales - from hotels booking rooms in multiple languages to sales teams practicing with AI.

AI Highlights from Around the Web

Is NVIDIA the Next Enron?

Ed Zitron dives deep into why NVIDIA keeps insisting it's nothing like Enron (which, honestly, makes people wonder even more). He breaks down the company's circular financing deals, inventory questions, and the massive GPU orders that seem to be piling up without clear profit paths. Read the full analysis.

Read the full article.

🌶️ Value is being created with AI - is it enough for the valuations? Time will tell but with the massive investments being made, look for new competition to spring up to NVIDIA and other infrastructure providers.

Enterprise AI Is Actually Happening

OpenAI just dropped their first-ever enterprise AI report, and the numbers are wild. Weekly ChatGPT Enterprise messages jumped 8x in a year, workers are saving 40-60 minutes daily, and 75% say AI improved their work speed or quality. But here's the kicker - the gap between power users and everyone else is widening fast.

Check the report.

🌶️ Enterprises are spending and seeing results. Here at Chipp, we're focused on the "Chipp Flipp" - bringing these opportunities to every business no matter how big or small.

The Real Cost of Selling AI to Big Companies

Harry Stebbings drops an unpopular truth - you can't just sell AI tools to large enterprises and expect them to stick around. Without hands-on implementation support and customization (think full white-glove service), companies won't adopt it. The art isn't in the product, it's in making it actually work for them. Explore the insight.

Explore this tweet.

🌶️ Forward deployed engineers, or FDE's, is the term de jour - it's really just a consultant or onboarding. We recently added addition support for "do it for me" requests because hand holding gets AI to be sticky.

OpenAI Gets 400x More Efficient in One Year

Steven Adler highlights OpenAI's massive efficiency gains - dropping from $4,500 per problem to just $12 in one year. That's a 400x improvement. The catch? Human labor costs don't drop 400x annually, creating a widening gap between what AI can do and what it costs versus human alternatives.

Explore this tweet.

🌶️ Price drops are continuing with AI. As AI is cheaper we will start to do tasks we never considered because it was prohibitively expensive. That will change how we work.

ChatGPT Apps Are Coming

Romain Huet announces builders can now submit ChatGPT apps. This opens the door for UI-driven experiences that feel like natural extensions of conversations, powered by MCP. First approved apps roll out in the new year.

Check out the details.

🌶️ It will be fascinating to see if businesses want to disintermediate their relationships with customers. ChatGPT will offer a massive opportunity for user acquisition, but companies will be giving up data and direct connection. Look for lots of experimentation here.

Chipp Updates

We're Working with Stripe on Usage-Based Billing for AI

We're Working with Stripe: Bringing Usage-based Billing Solutions to Small Businesses

Small businesses shouldn't have to compromise on AI quality because of unpredictable pricing. That's why we worked with Stripe as their first design partner on Billing for LLM tokens. Now you can use the best models for each task and only pay for what you actually use. Every Chipp subscription includes 1/3 of your plan value in monthly tokens - that's roughly 10 million words a month.

Read the blog.

Voice as the New Interface

Scott explores why voice is transforming customer support. From hotel guests booking rooms in multiple languages to sales teams practicing pitches with AI, voice removes friction and lets people communicate naturally.

Read the blog.

We're Working with Stripe: Bringing Usage-based Billing Solutions to Small Businesses

The Best Models Solve the Biggest Problems

Traditional software pricing doesn't work for AI. A flat $20/month subscription makes sense when every user costs roughly the same to serve. But with AI, one user might send 10 simple questions while another runs 500 deep research queries. The costs are wildly different.

This forces AI companies into an impossible choice: charge everyone a high flat fee (unfair to light users), cap usage aggressively (limiting what you can build), or lose money on power users.

We refused to accept any of those options.

What This Means for You

We worked with Stripe as their first design partner on Billing for LLM tokens—a new way to handle AI pricing that finally makes sense.

We did this to allow our customers to be able to pay for their Chipp usage based on the models and complexity they need.

Previously, you paid regardless of the business value and outcome that you were able to achieve. Now you can leverage the best tools to solve your customer's problems and get charged based on that specific consumption (and by proxy, the business value you're delivering).

What's more, every Chipp user gets 1/3rd of their subscription in monthly tokens - so a $99/mo plan has $33 worth of tokens every month as an example. That's a ton! Roughly 10m words a month or so on GPT-5 Mini or Gemini 2.5 Pro.

"We've been working with Chipp on a new product around how you pay for LLM tokens and how you bill your customers for LLM tokens, which has become a massive cost center for tons of new AI SaaS startups." — Kimberly Hou, Engineering Manager, Stripe

Here's what this new model unlocks for you:

Use the right model for each job. Need a quick answer to "What's your return policy?" Use a fast, affordable model. Need to research competitors, analyze data, or provide personalized recommendations? Use the most powerful models available. You're not locked into one-size-fits-all. And you can use your monthly tokens on any model.

See exactly what you're paying for. Every query, every model, every cost—visible in your dashboard. No black boxes. No surprise bills. Set up alerts and payment thresholds so you have control.

Access frontier models from day one. GPT-5, Claude Sonnet and Opus, Gemini—the same models powering tools at the biggest companies are now available to a one-person shop building their first AI agent.

"Very quickly the cost starts stepping up. In that world where you have some users with $1 worth of usage and others with $100, a $20 fixed fee doesn't work so well anymore." — Nick Dowse, Software Engineer, Stripe

Democratizing Access to the Best Tools for Small Businesses

This work makes AI accessible and practical for businesses that don't have engineering teams or six-figure AI budgets.

When a local boutique hotel can deploy the same quality AI concierge as a global chain—trained on their specific rooms, their neighborhood restaurants, their unique personality—that's the playing field we're trying to level.

Your AI agent should feel like *your* brand, not a generic chatbot. And you shouldn't need to choose between quality and affordability to make that happen.

Here’s how that looks in the real world.

How AI Model Mixes Work in the Real World

We're not talking theory. We're actively deploying this into hospitality as a cornerstone vertical, and the results speak for themselves.

The smart model mix in action:

A hotel guest asks "What time is checkout?" → Fast, efficient model. Instant response. Minimal cost.

A hotel guest asks "I'm celebrating my anniversary tonight—what's the best restaurant within walking distance with a romantic atmosphere, good wine list, and availability for two at 8pm?" → Powerful model with web search capabilities. Thoughtful, personalized recommendation. Worth the extra cost.

With usage-based pricing, hotels aren't forced to choose. They can handle high-volume simple queries affordably while delivering exceptional service on the moments that matter.

And we're pairing this with voice. As we give customers access to the best models through usage-based pricing, we're also rolling out voice agents that can answer calls, handle bookings, and provide concierge support—24/7, in any language.

See it in action: Check out how we're already working with hotels, and the massive ROI they're seeing only shortly into their engagement with Chipp: chipp.ai/hospitality

Why Transparent Pricing Improves AI Quality

We didn't use Stripe just for the aura (though yes, Stripe is an awesome company to work with). We worked together because this solves a real problem that was holding back our users.

When Kimberly and Nick from Stripe came to our launch event and walked through the integration live, it validated something we'd believed from the start: small businesses shouldn't have to compromise on AI quality because of unpredictable pricing.

When businesses can choose the power and price of each task, they can build sustainable business workflows. This is essential for the long-term impact of AI for actual business use.

"We started working with close design partners, people like Chipp AI, to build out a first version of usage-based billing—billing the customer based on how they're using your product, but specifically for LLM tokens."

— Nick Dowse, Software Engineer, Stripe

Together, Stripe and Chipp are building transparent pricing to power the next generation of AI use.

We gave feedback. They built. We tested. They refined. The result is a billing system that finally matches how AI actually works.

*See the system in action:*

Token Billing - Kimberly Hou & Nick Dowse | Chipp Con 2025

What You Can Do Now

1. Build with confidence. Pick a model to match your task. Use cheaper models for simple queries, and only use more expensive models for complex workflows.
2. Check your usage. Head to Settings → Billing to see exactly which models you've used and what they cost.
3. Learn more about pricing. Our Chipp Docs has an entire section on tokens. Visit this page to learn more and use our token estimator to see how many tokens you might use. Full pricing is shown on our Guide to Tokens post here.
4. Build with us live. Thursday we are hosting a workshop on building your customer support agent. See the usage pricing in action and walk away with phone, internet, and WhatsApp support. Learn more and register here.

*Chipp is one of Stripe's first Billing for LLM tokens alpha users. We're using this technology to bring transparent, usage-based AI pricing to small businesses.*

Whether you’re capturing new leads, sending progress updates, automating onboarding, or alerting your team to VIP requests, triggering emails from Chipp’s conversation logs opens a world of smart automations for no-code AI enthusiasts. Think:

• New customer alert: Instantly email yourself or your sales team when a prospect drops their contact info or says “I’m interested.”
• Support resolution: Send a summary to clients when their issue is marked as resolved.
• Personalized onboarding: Fire off a customized onboarding email when someone completes their first chat.
• Project follow-ups: Nudge yourself or the client automatically when certain topics are discussed.

If you can dream it, you can do it—no code needed.

🎥 Watch the Full Tutorial

See the process live: How to Trigger Emails from Chipp Conversation Logs (YouTube)

Step-by-Step: Triggering Emails from Chipp Conversation Logs

How to Trigger Emails from Chipp Conversation Logs

Follow these direct steps, as shown in the video, to set up email automations in Chipp:

1. Access Your Chipp Conversation LogsOpen Chipp and navigate to your project’s dashboard.Go to the “Logs” tab on the left sidebar to see recent conversations.
2. Open Chipp and navigate to your project’s dashboard.
3. Go to the “Logs” tab on the left sidebar to see recent conversations.
4. Export the Conversation LogIn the logs tab, click on the conversation you want to use as your trigger.Look for the three-dot menu (⋮) in the top right, and select .
5. In the logs tab, click on the conversation you want to use as your trigger.
6. Look for the three-dot menu (⋮) in the top right, and select .
7. Copy the Webhook URL for AutomationYou’ll be prompted with a webhook URL—this is the secret sauce for automating actions from your logs.Copy the provided webhook link to your clipboard. This link can trigger other apps when a new conversation log is created or matches specific conditions.
8. You’ll be prompted with a webhook URL—this is the secret sauce for automating actions from your logs.
9. Copy the provided webhook link to your clipboard. This link can trigger other apps when a new conversation log is created or matches specific conditions.
10. Plug the Webhook Into Your Email ToolOpen your favorite no-code automation platform (Zapier, Make, Pipedream, or any tool that works with webhooks).Create a new automation (“Zap,” “Scenario,” or similar) that starts when a webhook is received.
11. Open your favorite no-code automation platform (Zapier, Make, Pipedream, or any tool that works with webhooks).
12. Create a new automation (“Zap,” “Scenario,” or similar) that starts when a webhook is received.
13. Configure the Email ActionSet up the following step to send an email—using the data pulled from the conversation log (like the name, email address, or message details).You can customize the subject and body of the email with information from the chat.
14. Set up the following step to send an email—using the data pulled from the conversation log (like the name, email address, or message details).
15. You can customize the subject and body of the email with information from the chat.
16. (Optional) Filter or Format Your TriggersAdd filters so emails are only sent when certain keywords or phrases appear in the chat.Personalize emails using details from the log (like customer name or request type).
17. Add filters so emails are only sent when certain keywords or phrases appear in the chat.
18. Personalize emails using details from the log (like customer name or request type).
19. Test and DeployTest the automation with a sample chat to ensure the right people receive the right email.Once happy—turn it on and let Chipp + your automation platform do the rest!
20. Test the automation with a sample chat to ensure the right people receive the right email.
21. Once happy—turn it on and let Chipp + your automation platform do the rest!

What Will You Automate Next?

This is just the beginning! Chipp conversation log automations can free up your time and deliver lightning-fast follow-up to your customers and team. Let your AI agent work smarter, not just harder.

👉 Ready to try it? Start building with Chipp.ai for free

For the full, step-by-step video guide, check out: How to Trigger Emails from Chipp Conversation Logs (YouTube)

Related Links:

• Chipp.ai Templates
• Chipp Academy
• Chipp Community

That's why we built Token Billing. You can see your usage starting today with all plans being upgraded next week.

Token Billing Launch - The Best AI for Everyone, Only Pay for What You Use

How It Works

Log into your Chipp settings. Go to billing. Done.

Every plan now comes with built-in tokens. A third of your subscription goes straight to AI usage. You choose how to spend it.

Fast models for simple tasks. Powerful models for deep research. Your call.

Full Transparency

Scroll down to your invoice. Every model, every cost, right there.

No mystery pricing. No surprise bills. You see exactly what you're using and what it costs.

Set alerts when you're running low. Add tokens automatically or get notified—whatever works for you.

No Limits

Gemini can handle 750,000 words per request. GPT-5, Claude Sonnet and Opus, the full lineup—all available.

You pick the model. You control the spend. Build without artificial constraints.

Learn More

Want to understand tokens better? Check out our Guide to AI Tokens and our interactive docs where you can visualize exactly how tokens work.

Quick reference: 100 tokens ≈ 75 words.

Now go build!

We teach our children to read. We teach them to write. But speaking? They figure that out on their own. It's the most natural thing humans do.

Voice is the original interface. Now it’s the next interface.

AI improves the accuracy and speed of voice conversations. Now, you can speak to your computer or phone, taking action on the go in the way we’ve always communicated.

This shift to voice is changing how we shop and work. It's also changing expectations for customer service. We’re seeing this first hand with travelers and the hospitality industry.

Build your AI customer service agent in 60 minutes. Join our workshop December 18th. All registrants get the replay. Register for the Workshop

Using Voice to Help Customers Book a Room in Any Language

One Chipp partner is a large hotel group that uses WhatsApp to help visitors book rooms through AI chat. The behavior patterns are striking.

Guests don't type. They speak.

Not because we told them to. Because it's easier. A traveler switching between English and Spanish mid-conversation doesn't want to worry about grammar or spelling. They want to book a room.

In Dubai, where the Chipp user is based, residents are constantly switching between languages. They can get by speaking a language, but writing? That’s much more difficult.

Voice removes the anxiety. Voice removes the friction. Voice lets people communicate the way they've communicated for 200,000 years.

*View the case study and highlights on how hospitality is using voice **here**.*

Customer Support: From Phone Tree to Phone Rainforest

We've all suffered through the phone tree.

"Press 1 for billing. Press 2 for technical support. Press 3 to speak to a representative. Press 4 to lose the will to live."

The phone tree is a relic. It forces customers into rigid paths because the technology couldn't handle anything else.

Enter the phone rainforest.

Natural conversation. Any question. Real answers or intelligent routing. The way humans actually communicate.

Hotels can now book rooms this way now. Guests call, speak naturally about what they need, and the AI handles it. No menus. No "I didn't understand that." Just conversation.

Here's the deeper shift: we need to reclaim the term "answering machine."

Answering machines never answered anything. They took messages. They were message machines pretending to be something more.

Today, we can build actual answering machines. Systems that handle inbound questions, provide real answers, and only take messages when genuine follow-up is needed.

This is what unlocks voice for business. Not message-taking dressed up as automation. Actual answers. Actual resolution. Actual value.

Sales Training: Practice Before the Stakes Are Real

Here's a question every sales manager faces: how do you know if a candidate can actually sell before you put them on the phone with real customers?

The old answer: you don't. You hire, you train, you hope.

Voice AI changes this completely.

Candidates can now have full conversations with AI personas representing your typical customer archetypes. The skeptical enterprise buyer. The budget-conscious small business owner. The technical decision-maker who needs specs.

Hiring managers review the recordings. They read the transcripts. They see how candidates handle objections, build rapport, close.

All before a single real customer interaction.

The same applies to existing teams. Sales reps can practice new pitches, rehearse difficult conversations, refine their approach. The AI provides feedback. Reps get unlimited reps.

Lower stakes. Higher volume. Better outcomes.

See how it works for Wolf Automotive in their Sales Trainer. Just click enable microphone. If you're in your email or can't see it, click here.

Try It Yourself

Theory is one thing. Experience is another.

Below is a voice AI agent. Click enable microphone and talk to it. Ask questions. Have a real conversation. (If you're reading in an email, click here.)

Notice what happens. The conversation feels natural. You're not navigating menus or choosing from options. You're just talking.

Now look at the backend.

The AI extracts information from the conversation— interests, needs, suggestions, and contact details if you offer them.

Then, alerts are set up to send emails with conversation snippets of the most important leads.

This is lead capture through conversation, not forms.

That data flows directly to the business. A sales team gets notified. Follow-up happens. All from a conversation that felt like talking to a knowledgeable colleague.

This is the new funnel. Not clicks and form fills. Conversations and conversions.

Hire Your AI Customer Support Agent [Workshop]

Voice is already here as the new/old interface. It may take some organizations time to catch up, but it shouldn't.

Here at Chipp, we're passionate about helping every organization have access to the best AI. That's why we now offer voice agents you can train on your data and use on the phone as sales agents.

If you want to learn more, join us December 18th for our workshop: How to Build a Customer Support Agent.

This is a hands-on session. You will walk away with a functional support agent for your website, phone, or WhatsApp.

Sign up here...and keep talking!

In this lesson you'll learn how to see your user interactions with your Chipp and how to connect your chatlogs to Google Sheets.

Watch the two tutorials below to learn... 👇

1. How to activate / deactivate user chatlog tracking
2. How to download chatlogs as a CSV
3. How to connect your chatlogs to your Google Sheets (see video tutorial #2 below)

How To Manage Your User History & Chat Logs

Connecting to Google Sheets

Connecting Chat Logs to Google Sheets

Lesson 2: How to Make the Most Out of Chatlogs

In this lesson you'll learn how to make the most out of Chipp chatlogs to use them for research at scale.

Watch the tutorials below to learn when and how to use... 👇

1. Chatlogs fundamentals (video 1)How to connect chatlogsHow to use chatlogsHow to connect to Google Sheets (video 3)
2. How to connect chatlogs
3. How to use chatlogs
4. How to connect to Google Sheets (video 3)
5. How to use Chatlogs for research at scale (video 2)

Chatlogs fundamentals

Chatlogs Fundamentals

How to use Chatlogs for research at scale

How to use Chatlogs for at Scale Research

How to connect to Google Sheets

Connecting Chat logs to Google Sheets

Lesson 3: How to Automate Chatlog Analysis

Watch the tutorials below to learn when and how to.. 👇

1. Create and optimize an analysis bot to help you with product feedback (video 1)
2. Share analysis bot with clients without back-end access (video 2)

How to Create and Optimize an Analysis Bot

Share and Use Analysis Bot without Back-end Access

Lesson 4: How to Use Tags to Monitor Specific Words in Your Chat Logs

With tags, you can track conversations about marketing leads, product questions, or sensitive topics like self-harm. Set up example phrases, adjust sensitivity, and even automate responses or actions—like sending alerts or emails—using webhooks and integrations.

Tags help you quickly find important conversations, respond to urgent issues, and streamline your workflow.

Watch the tutorial below to learn when and how to.. 👇

How to Monitor Specific Words in Chat logs using Tags

Lesson 5: How to Use Chatlogs to Improve your Chipps

In this lesson you'll learn the different ways in which you can limit who can access your Chipp apps.

Watch the video between 3:20–4:00 to learn 👇

How to use your Chatlogs to improve your Chipp Chat experience

AI in Action: How Tyler Hansen Leverages AI in Plumbing and Heating

Lesson 6: How to Monitor Use Chats with Tags

Learn more about using tags in the tutorial below

You can use tags for many use cases such as:

• Track leads or purchase intent
• Tag harmful conversations

What will you use tags for?

How to Use Tags on Chipp

In this lesson you'll learn when and how to use the different sharing options on Chipp.

Watch the tutorial below to learn to... 👇

1. How to share your Chipp with a direct URL
2. How and when to use iframe embeds
3. How and when to use the widget
4. How to share them using your creator profile

How to Share Your Chipp AI Agents

Lesson 2: How to Share Your AI Apps Using the Chipp HQ

In this lesson you'll learn how to share your chipp apps via your Chipp HQ.

Watch the tutorial below to learn... 👇

1. What the HQ is?
2. How you can share your apps with your team, your potential customers and others using the HQ.

Chipp HQ – How to set-up and use your digital AI storefront

Lesson 3: How To Manage Workspaces & Share Chipps With Your Team

In this lesson you'll learn when and how to use private and shared workspaces and how to invite team members to your workspace.

Watch the tutorial below to learn... 👇

1. The difference between a private and shared workspace
2. How to invite others to your team workspace
3. How to use private workspaces to build in private and share when ready.

How To Manage Workspaces & Share Chipps With Your Team

Lesson 4: How To Transfer & Duplicate Your Chipps

In this lesson you'll learn when and how to duplicate and transfer your Chipps.

Watch the tutorial below to learn... 👇

1. When and how to transfer your Chipps to other workspaces
2. When and how to use duplicates e.g. for:personal copies of Chipps that you've transferred maintaining copies for version history
3. personal copies of Chipps that you've transferred
4. maintaining copies for version history

🚨 NOTE:🚨 After duplicating your Chipps, they are no longer connected to one-another. So if and when you make changes to either the original, or the duplicate, the changes will only apply to that one Chipp. Also any Chat history that you had in your original Chipp will not transfer to the new Duplicate.

How To Transfer & Duplicate Your Chipps

Lesson 5: How to Deploy Chipp to Slack

In this lesson you'll learn how to deploy your Chipp app on Slack.

Find Deployments under "Share" and Deploy tab.

How to Deploy Chipp to Slack

Lesson 6: How To Customize & Brand Your Chipps

In this lesson you'll learn how to change the theme, colors and logos on your Chipp.

Watch the tutorial below to learn to... 👇

1. Change the theme on your Chipp
2. Upload your custom logo on your Chipp
3. Modify the Colors on your Chipp
4. Link the CTA button on your Chipp to direct to your preferred URL

How To Customize & Brand Your Chipps

Lesson 7: How To Add A Custom Domain

In this lesson you'll learn how to add a custom domain for your Chipp. This means changing your Chipp URL from e.g. "chat-6842.chipp.ai" to "chat.mydomain.com".

Find the Custom Domain under "settings" in the new Chipp App.

Watch the tutorial below to learn... 👇

1. How to create a subdomain for your ChippChipp.aiYour Domain Provider (e.g. godaddy, hostinger or other)
2. Chipp.ai
3. Your Domain Provider (e.g. godaddy, hostinger or other)
4. Accessing your DNS settings on your website hosting provider's website (depending on your website hosting provider)
5. Choosing between different types of records (A, CNAME etc...)
6. Adding a CNAME record
7. Adding "name" or ""title" (= choosing what your subdomain name for the specific chipp chat is. This can be anything you want, e.g. ai, chat, expert...)
8. Adding value "custom.chipp.ai" (always the same)
9. Save on your hosting provider site
10. Return to Chipp.ai to input your saved custom domain (e.g. chat.scottdavidmeyer.com)

How To Add A Custom Domain

Lesson 8: How to embed iframes with user sign-up enabled

In this lesson you'll learn how and when you need to use custom URL's to enable user sign-up iframe integration.

Watch the tutorial below to learn to... 👇

1. How to make a user sign-up enabled app work on an iframe.

User Signup vs iFrames in Chipp

Lesson 9: How to Embed Your Chipp Apps on Squarespace

In this lesson you'll learn how to embed your Chipp chats on Squarespace.

Embedding Chipp AI Agents into Squarespace

Lesson 10: How To Limit Access To Your Chipps

In this lesson you'll learn the different ways in which you can limit who can access your Chipp apps.

Watch the tutorial below to learn to... 👇

1. User sign-up (= user needs to sign-up with email & password to access the Chipp). 👉 Great option when you have a Chipp that anyone can start using when they find it.
2. Redirect after sign-up (separate video tutorial coming soon!)
3. Domain Whitelisting (= give access only to emails with specific domains: e.g. google.com, scottmeyer.com) 👉 Great option for Chipps that are only shared with specific company emails.
4. Email Gating (=give access to individual emails either by typing them in, or importing as a CSV) 👉 Great option for e.g. giving your newsletter email list access to your Chipp app.

How To Limit Access To Your Chipps

Lesson 11: How to Share Your Chipps with the HQ

Learn how you can share and sell your Chipps through the HQ (AKA Headquarters)

Sell AI Agents with Chipp

Lesson 12: How to Create & Share your Branded Chipp Widget

Learn to customize your Chipp Widget to fit your branding and share it with your audience

Create a Branded AI Chat Widget for Your Website - ChatGPT for Your Site

This week, we're exploring vertical AI's winning playbook, Meta's AI-driven advertising shift, and how AI is fundamentally rewiring the economy from consumerism to human flourishing.

On the Chipp side, learn how to **build your support team with voice** in our December 18th workshop, and if you're ready to move fast, **get your custom AI agent built in 2-4 weeks** with Chipp Exec. Catch the **replays from Chipp Con SC** where Stripe, Google, and builders shared strategies for brand-native AI. Here's a sneak peek:

Chipp Con: SC - Brand-Native AI in Action at the 2025 Conference in Greenville, SC

AI Highlights from Around the Web

Vertical AI Companies Are Winning Big

Rohit Mittal shares how PermitFlow just raised $54M by focusing on one thing construction companies hate: permitting. Instead of trying to solve everything, they built specialized AI agents for permitting, inspections, and licensing.

Explore this tweet

🌶️ We're seeing more businesses looking to buy a specific solution for a narrow problem. AI enables software to solve problems that previously were too niche to consider.

Meta's AI Is Quietly Changing Advertising

BuccoCapital Bloke highlights a game-changing moment from Meta's earnings call. Advertisers can now give Meta a business goal and credit card, and the AI figures out everything else. This shift toward AI-driven campaign management could massively expand who can advertise.

Explore this tweet

🌶️ AI is already paying dividends for Facebook - forget their efforts to create new models and super intelligence. Expect AI to quickly generate ads, including videos, for any brand soon with just a goal and budget.

AI Is Rewiring the Economy

Genuinrisk calls out a phenomenal article exploring how AI will reshape business models. The piece argues we're using tomorrow's tools in old business models, and a new economy has to emerge where AI creates abundance in services while scarcity emerges in consumer spending.

Explore this tweet.

🌶️ AI brings service to everyone: a personal lawyer, a personal accountant, a personal counselor. Just as the container dropped the price on goods, AI will do the same to service. You can start now by building your own service agent.

Vertical AI Is Having Its Moment

Ben Smith points out that vertical AI companies like Harvey, Abridge, and OpenEvidence crossed billion-dollar valuations by embedding deeply into workflows that traditional software never cracked. The playbook? Own the workflow, build data moats, and price on outcomes instead of seats.

Explore this tweet.

🌶️ When you have a personal service provider, you can scale that to your niche. We are starting to do the same with hospitality.

Chipp Updates

Building Your Support Team with Voice

Your customers have questions at 2 AM. Your clients need help on weekends. Your team can't be everywhere at once. What if you could be?

Join us on December 18th at 11 AM CT as we show you how to build a 24/7 support team using Chipp's newest feature: voice. We'll walk through real use cases and show you exactly how businesses are using voice to answer customer questions any time of day, provide instant support without the wait, and scale their team without scaling their headcount. **Register here.**

Catch the Replays from Chipp Con SC Talks

We brought together builders, founders, educators, and AI experts from around the world to Greenville, South Carolina for Chipp Con SC. We heard from industry experts like Stripe and Google, business leaders in agencies and schools, and the Chipp team on how they're using Chipp for sales, support, and marketing.

**View all the talks and highlights here.**

Get Your Custom AI Agent Built in 2-4 Weeks

Stuck on your AI journey? Want to integrate AI before the end of the year but still figuring it out?

Introducing Chipp Exec: the done-for-you version of Chipp. We'll build your custom AI agent from concept to deployment in just 2-4 weeks.

Choose from three powerful options: Chipp Sales (make sales while you sleep), Chipp Support (elevate every customer interaction), or The Operations Optimizer (supercharge your internal workflows).

Each build includes one core agent and its primary deployment, with options to add WhatsApp integration, 24/7 phone agents, or web deployment.

**Learn more.**

Understand the three types of knowledge

In this lesson you'll learn the different types of knowledge AI can use.

Watch the tutorial below to get ideas for... 👇

1. What the three types of knowledge are (video 1)
2. Why upload knowledge on top of the AI's existing knowledge (video 2)
3. The technical difference between knowledge sources vs. prompts (video 3)

Three Levels of Knowledge

Why upload knowledge on top of the AI's existing knowledge

Why upload knowledge on top of the AI's existing knowledge

The technical difference between knowledge source vs. prompt

Knowledge Sources vs. Prompts

Lesson 2: How to Update Knowledge Sources Automatically

How to automate refetching of knowledge sources

Watch the tutorial below to learn when and how to automate refetching for your knowledge sources.

How to automate refetching of knowledge sources

Lesson 3: Difference between knowledge source vs. Prompt

Watch the tutorials below to learn when and how to use knowledge sources vs. system prompts to optimize output

Knowledge Sources vs. Prompts

Lesson 4: How to use Markdown to Optimize your Chipps

How and Why to use Markdown to optimize your Chipps' performance?

Below you can find a quick introduction to HOW and WHY use Markdown to optimize your Chipps. Mastering the basics of Markdown for both instructions and knowledge sources can make a massive difference in the accuracy and ease of editing of your AI tools.

Watch the tutorial (& read the lesson) below to get ideas for... 👇

1. How to make sure your AI understands exactly what you're trying to say by using Markdown.

Introduction to Markdown (using Markdown)

## What is Markdown?

Markdown is a simple way to add formatting—like bold, italics, lists, and headings—to plain text. It’s widely used in online writing, documentation, and AI tools to make instructions clearer and more organized.

## Why Use Markdown in AI Instructions?

- Clarity: Well-formatted instructions are easier for both users and AI assistants to understand.

- Emphasis: You can highlight important words or steps, making sure nothing gets missed.

- Organization: Headings and lists help break information into manageable sections.

## Basic Markdown Formatting

Here are some easy ways to use Markdown:

Headings: Use #'s to help your AI know which sections belong where in hierarchy. E.g. Heading 2 (##) belongs under Heading 1 (#), and Headings 3 (###) belong under both Headings 1 & 2.

# Main Section Title

## Section Title

### Subsection

#### Sub-subsection

etc...

Bold and Italic:

Bold for important words

*Italic* for emphasis

Lists

- Step 1

- Step 2

- Step 3

**Links:**

If you'd like to learn more, or have access to more examples on markdown and using html in your Chipps, you can find a great list here: https://www.markdownguide.org/basic-syntax

## How to Use Markdown in Your AI Instructions

When you write instructions for your AI assistant, use Markdown to:

- Make step-by-step guides with clear sections and hierarchy.

- Highlight key actions or warnings in bold.

- Organize long instructions with headings.

### Example

Plain instruction:

Please collect user feedback and send a thank you message.

With Markdown:

## Collect Feedback

- Ask the user for their feedback.

- Thank the user for their input.

- Save the feedback for future improvements.

Using Markdown helps your AI assistant communicate more clearly and professionally—no coding required!

Lesson 5: How to Share Images & Gifs in Your Chipp

How to add images or gifs to your Chipp apps using Markdown

Below you can find a quick introduction to how you can share images and gifs as a part of your Chipp user flow.

Watch the tutorial (& read the lesson) below to get ideas for... 👇

1. How to use images & gifs to liven up your Chipp chats

How to Share Images & Gifs in Your Chipp

Lesson 6: How to Optimize Video on Chipp

How to optimize video on Chipp?

In this lesson you'll learn when and how to upload videos into knowledge vs. when to have your users upload them in the chat.

Watch the tutorials below to learn when and how to use... 👇

1. Instructions to guide your use case (video 1)
2. Knowledge uploads for your use case (video 1)
3. How to make the most out of prompting and chatting with your videos (video 2)
4. How to use example videos for optimized experience (video 3)
5. How to use video to see and observe to analyze the visuals (not just audio) of video (video 4)

Knowledge uploads for your use case

How to optimize the video feature on Chipp

How to Optimize the Video Feature on Chipp

How to use video examples to train your Chipp

How to Use Video Examples to Train your Chipp

How to use the multimodal abilities of video on Chipp

How to use the multimodal abilities of video on Chipp

How to use video to see and observe to analyze the visuals of video

How to Use Video to Analyze the Visuals

Lesson 7: How to Use Video for Research & Feedback (Youtube, TikTok, Instagram)

How to Use Video for Research & Feedback (Youtube, TikTok, Instagram)

In this lesson you'll learn how to use video to get feedback on e.g. your speaking, understanding viral videos etc.)

Watch the tutorials below to get ideas for... 👇

1. How to use Youtube, Tiktok or other forms of video to get feedback.

How to Use Video to Analyze the Visuals

Lesson 8: How to Create Image Variations for Social Platforms

How to create image variations for AD platforms

In this lesson you'll learn how to use the image generation tool to create variations of the same image to fit different platforms or purposes.

Watch the tutorial below to get ideas for... 👇

1. How to create image variations for FB, Instagram

How to Create Image Variations for Social Platforms

Lesson 9: How to Train a Personalized Curriculum Creator

How to create a curriculum crafter with Chipp

In this lesson you'll learn how to create a structure for anyone to upload information, and get a personalized lesson plan as the output.

Watch the tutorial below to get ideas for... 👇

1. How to help students create fully personalized lesson plans or growth paths

Generating Personalized Curriculum with AI

Lesson 10: How to Create Videos with Chipp

Learn how you can create videos using Gemini 2.5, AKA Nano Banana on Chipp

How to use Nano Banana (Gemini 2.5) Image Creator on Chipp

We heard from industry experts like Stripe and Google, business leaders in agencies and schools, and the Chipp team. We launched new features...and ate lots of barbecue.

The barbecue isn't on video but the rest is!

Here's a quick highlight video from the event:

Chipp Con: SC - Brand-Native AI in Action at the 2025 Conference in Greenville, SC

Catch up on all the speakers and their keynotes below 👇🏻

Creator Power. Structural Support. AI ENABLED.

*by Alfredo Narez, **The PMF Academy*

Alfredo Narez, founder of PMF Academy, shows how AI can turn anyone into an unstoppable creator. He demonstrates how his AI agents work like IP attorneys and business advisors, shares how he went from begging for LinkedIn likes to top 4% in the world in 90 days, and introduces Eva, an AI travel assistant.

Creator Power. Structural Support. AI ENABLED - Alfredo Narezo, The PMF Academy | Chipp Con 2025

AI Agency - The Age of Brand-Native AI

*by Scott Meyer, **Chipp*

We were thrilled to launch five new features in the Chipp Builder as we shared that we are in the year of agency. We have the power to take action if we are bold enough to take the first step. See the new features in this keynote.

The Year of AI Agency: Building Brand-Native AI with Chipp v2 | Chipp Con 2025 in Greenville, SC

Usage-Based Billing, The Stripe + Chipp Partnership

*by Kimberly Hou & Nick Dowse, **Stripe*

Why does a $20 monthly subscription stop making sense when one user costs you $1 in AI usage and another costs you $100? Kimberly and Nick from Stripe's Experimental Projects team explain how LLMs fundamentally changed software pricing and walk through their solution: token billing that lets you set up usage-based pricing in 5 minutes. They demo how Chipp integrated it to give users complete transparency on what each query costs.

Usage-Based Billing - Kimberly Hou & Nick Dowse | Chipp Con 2025

Google's Vertex AI Platform Partnership with Chipp

*by Jen Diffenderfer, **Google*

Jen Diffenderfer from Google explains how the Vertex AI platform powers Chipp's infrastructure, giving builders access to scalable, flexible AI with zero data retention. She shares how Google's Veo created NBA Finals commercials for $2,000 in 2-3 days and addresses the constant pressure founders face to innovate and keep up. Her talk covers the three pillars for choosing a technology partner: scale, choice and flexibility, and building on trust with full control over your data.

Google's Vertex AI Platform Partnership with Chipp - Jen Diffenderfer, Google | Chipp Con 2025

Using AI to Sell Hotel Rooms: A Global AI Intelligence Hub for Modern Businesses and Hospitality

*by Amit Vyas & Andrew Thomas, **NEXA AI Lab*

Amit Vyas and Andrew Thomas run the NEXA AI Lab in Dubai, where they're using Chipp to replace hotel booking forms with WhatsApp conversations. After just 3 weeks live with Rove Hotel, they've seen 1,000 chats, 20 bookings, and $12,000 in revenue with 6-second response times. They're applying the same conversational approach to travel insurance quotes and e-commerce, proving that nobody wants to fill out forms anymore - they just want to have a conversation and get what they need.

Global AI Intelligence Hub for Modern Businesses - Andrew Thomas & Amit Vyas, NEXA | Chipp Con 2025

Owning Your AI: The Power of AI and Faith

*by Don Barger, **International Mission Board*

Don Barger is the Director of Innovation and AI at the International Mission Board, where he's built hundreds of AI chatbots including Faithbo, a tool with nearly 200,000 users across 35+ languages. He monitors sensitive conversations in real-time to ensure ethical AI responses and created a system that replaces education's worst busy work with AI tutors that won't let students finish until they prove they actually did the readings. His students prefer chatting with AI over writing 500-word responses, and he's offering to help educators set up similar systems for free.

Owning Your AI - Don Barger, International Mission Board | Chipp Con 2025

AI Tutor for Engineering

*by David Grewell, **NIU*

David Grewell is the Dean of Engineering at Northern Illinois University, where only 40% of students graduate with engineering degrees, mostly because of calculus. He partnered with Scott to build an AI tutor that behaves like a human tutor, asking questions and encouraging students instead of just giving answers, with 84% accuracy compared to 80% for human tutors. His goal is to use AI to increase the graduation rate from 40% to 70%, and he demonstrates the tutor live by walking through a calculus limit problem step-by-step.

AI Tutor - David Grewell, Northern Illinois University | Chipp Con 2025

From Grocery Lists to Strategy: AI for Family and Small Businesses

*by Justin Ahrens & Sarah Ahrens, **Rule29** and **(Re)Genesis*

What happens when a CEO meets an "AI resistor" who just wants help with grocery shopping? Justin and Sarah Ahrens share their honest journey of integrating AI into their 30-year marriage, 25-year creative agency, and chaotic family life. They increased their agency efficiency by 40%, turned proposals from 3-day projects into 3-hour wins, and built a side hustle helping small businesses - starting with real pain points instead of chasing tech trends.

From Grocery Lists to Strategy - Justin Ahrens, Rule29 | Chipp Con 2025

Leading in the Age of AI

*by Bob Gower, **rippleIQ*

Bob Gower spent years blasting angry emails to newsrooms, convinced he was making things better until he realized people hated him and nothing improved. Twenty years of organization design work later, he's figured out why most AI implementations fail: they're adding automation to broken systems, which just amplifies the problems. He shares the neuroscience of decision-making, introduces the Dutch healthcare company that destroyed efficiency metrics by giving nurses complete control, and demos rippleIQ.

Leading in the Age of AI - Bob Gower | Chipp Con 2025

Agents Need to Talk: Agent-to-Agent Protocol (A2A

*by Lia Passaglia & Christopher Penny, Google*

Lia Passaglia and Christopher Penny are AI specialists with Google who introduced Agent-to-Agent Protocol (A2A) - an open-source standard for how AI agents communicate with each other. Instead of building one all-knowing agent, A2A lets you plug in specialized agents that are really good at specific tasks, creating an "agent mesh" where agents discover each other, share what they can do, and collaborate. Google developed it, open-sourced it, and donated it to the Linux Foundation to create interoperability between different agents and turn isolated agents into Lego pieces that plug into any A2A system.

AI Agents Need to Talk - Lia Passaglia & Christopher Penny, Google | Chipp Con 2025

AI for Development: A Hands-on Tutorial

*by Hunter Hodnett, Chipp*

Hunter Hodnett is Chipp's CTO who runs three laptops at once, each with its own AI coding agent, to build features in parallel with a four-person team. He breaks down big features into smaller steps and creates summary documents that he feeds to the AI one step at a time, keeping things focused so the AI doesn't get overwhelmed. This is how Chipp ships so much with such a small team - they took bigger risks on AI development because they're fighting to survive in the market every day.

AI for Development: A Hands-on Tutorial - Hunter Hodnett, Chipp | Chipp Con 2025

Transforming Art Education with AI

*by Detria Graham, **Educator*

Detria Graham is an elementary art teacher in South Carolina using Chipp AI to manage lesson planning, gifted and talented testing, and parent communication for her second graders. She creates art lessons in the style of famous artists, builds literacy skills, and keeps everything organized in one place, which helped her win a grant from the American Folklore Society. Her work shows how educators can use AI to spend less time on paperwork and more time actually teaching.

Transforming Art Education - Detria Graham, SC Educator | Chipp Con 2025

The Origin of the Chipp HQ

*by Valentina Valverde, Chipp*

Valentina Valverde is Chipp's UI designer who built the HQ feature from front to back and refactored it twice as user needs evolved. What started as a simple way to display apps became a full marketplace where builders can share publicly, control workspace access, and monetize app bundles with Stripe. She walks through the complexity hiding behind the feature and demos how HQ works across different access modes.

The Origin of HQ - Valentina Valverde, Chipp | Chipp Con 2025

From AI Bot to Investment Call in 24 Hours

*by Vinay Gupta, **O.P.C.*

Vinay Gupta created a Palmer Luckey bot by feeding 10 hours of interviews into Chipp, which his friend used to get a defense tech investment deal in front of one of the world's hottest founders all within 24 hours. His talk shows the real text thread and proves that AI doesn't pull people apart when you focus on building solutions for real problems and people.

From AI Bot to Investment Call in 24 Hours - Vinay Gupta, Pulp Conversations | Chipp Con 2025

Homebuilt Aircraft - Building the RV14

*by Andrew Poland, Chipp*

Andrew Poland is Chipp's backend engineer who spends his weekends building an RV-14 airplane in his 1940s one-car garage. He walks through the process of turning 250-pound crates of sheet metal and 800 pages of CAD plans into a high-performance aircraft that goes 200 miles an hour - faster than any certified plane you can buy at this price point.

Homebuilt Aircraft Building the RV14 - Andrew Poland, Chipp | Chipp Con 2025

How to create Chipp apps using templates?

In this lesson you'll learn how to create a basic Chipp app with conversation starters, your selected AI model, basic prompts and custom URL knowledge sources.

Watch the tutorial below to learn how to... 👇

1. Name and describe your Chipp app
2. Change input text hint and use conversation starters
3. Train your Chipp chat with...Choosing your AI modelCreating a prompt (with and without prompt generator)Adding a URL knowledge source
4. Choosing your AI model
5. Creating a prompt (with and without prompt generator)
6. Adding a URL knowledge source
7. Test your instructions
8. View your chat history

How to Create a Chipp App

Want to learn more about creating better prompts?

Start with the video below or move over to our "how to AI" course for our detailed lessons on creating optimized prompts!

How To Customize Custom Chipp Chat Prompts

Lesson 2: How To Create A Chipp Using A Template

How to create Chipp apps using templates?

In this lesson you'll learn how to start creating your Chipp apps, without having to start from scratch.

Watch the tutorial below to learn how to... 👇

1. Search and find templates on Chipp.ai
2. Start creating Chipps with a template
3. Modify an existing template to fit your needs

How To Create A Chipp App Using A Template

Want to learn more about creating better prompts?

Start with the video below or move over to our "how to AI" course for our detailed lessons on creating optimized prompts!

How To Customize Custom Chipp Chat Prompts

Lesson 3: How To Activate & Limit Your Chipp App Capabilities

How (and when) to use different basic actions on Chipp?

In this lesson you'll learn how to define where and how your Chipp can access and share data, and which "basic actions" to use to optimize your user's experience.

Watch the tutorial below to learn when and how to use... 👇

1. File upload (= user uploads a file to share with the app)
2. Image generation (= the app can generate images for the user)
3. Image recognition (= the app can analyze images uploaded by the user)
4. URL retrieval (= the user can search specific URL's online)
5. Browsing Web (= the app can browse internet to share information with the user)

How To Activate & Limit Your Chipp App Capabilities

Do you have a question about Chipp academy?

(If you have a bug or feature request, share them at: https://updates.chipp.ai/)?ref=chipp.ai)

Do you want to know more about the community, Chipp or be featured in our social media channels?

1. DM Chipp Support or Maaria Tiensivu.
2. OR Email info@chipp.ai

Want to connect with other Chippers on our discord community?

Join here.

Lesson 2: How to report a bug or request features on Chipp?

Go to: https://updates.chipp.ai/.

See the short tutorial below for how to:

• Report bugs
• Request features
• Follow the Chipp roadmap
• Subscribe to updates

How to Report a Bug or Request Features

Or press: / on Discord and select "feedback" (see image below).

Lesson 3: How can I change my billing information?

See the short tutorial below for changing your billing information on Stripe.

How To Manage Your Account & Billing

What if you could fast-track your AI journey and have a powerful, custom-built AI agent up and running in weeks? No more getting stuck, no more delays. Just results.

You can. Meet Chipp Exec, the done-for-you version of Chipp. **Get started.**

The Chipp Exec Menu: What You Should Build

Our 2-4 week build projects are designed to deliver high-impact AI solutions tailored to your business needs. Each build includes one core agent and its primary deployment. Add additional deployments or agents as needed.

1. Chipp Sales: Make Sales While You Sleep

Imagine a tireless sales assistant, always on, always ready to convert. This agent is laser-focused on turning visitors into valuable leads and loyal customers. That's what you get with Chipp Sales.

• What it does: Provides instant, accurate answers about your products, services, pricing, and clear deliverables. It's designed to engage, inform, and close!
• Lead Generation Powerhouse: Escalates hot leads and critical topics directly to your inbox, ensuring you never miss a sales opportunity.
• E-commerce Ready: Seamlessly integrates with Shopify for direct sales, and can book calls with your team or link to other services right within the chat.
• Deployment Options - one included:🛜 Web & PWA: Lives directly on your website and as a Progressive Web App for maximum reach.📱 WhatsApp Integration: Engage customers where they are. Your trained AI Agent lives directly on WhatsApp, accepting bookings via custom links or Shopify. *Crucial Prerequisite:* You *must* have access to and already set up your Meta Business account *before* purchasing this service.📞 24/7 Phone Agent: Never miss a call! Deploy an AI Phone Agent to answer your phone calls and email leads directly to your sales team. It is finely tuned for voice AI and can suggest products or send detailst o CRMs, email, etc. *Note:* Phone numbers currently limited to US/Canada.
• 🛜 Web & PWA: Lives directly on your website and as a Progressive Web App for maximum reach.
• 📱 WhatsApp Integration: Engage customers where they are. Your trained AI Agent lives directly on WhatsApp, accepting bookings via custom links or Shopify. *Crucial Prerequisite:* You *must* have access to and already set up your Meta Business account *before* purchasing this service.
• 📞 24/7 Phone Agent: Never miss a call! Deploy an AI Phone Agent to answer your phone calls and email leads directly to your sales team. It is finely tuned for voice AI and can suggest products or send detailst o CRMs, email, etc. *Note:* Phone numbers currently limited to US/Canada.

Get Started

2. Chipp Support: Elevate Every Customer Interaction

Transform your customer service with an intelligent agent that provides comprehensive support, educates users, and resolves issues with lightning speed.

• What it does: Goes beyond basic FAQs, offering detailed information and in-depth explanations based on your extensive data and documentation.
• Customer Retention Champion: Improves satisfaction and retention by delivering efficient, accurate, and always-available support.
• Deployment Options:
• 🛜 Web & PWA: Your support hero, ready to assist on your website and as a Progressive Web App.
• 📱 WhatsApp Integration: Provide instant support on WhatsApp! Your trained AI Agent handles inquiries and provides information directly. *Crucial Prerequisite:* You *must* have access to and already set up your Meta Business account *before* purchasing this service.
• 📞 24/7 Phone Agent: Offer round-the-clock phone support! Deploy an inbound AI Phone Agent, trained on your company's knowledge base. *Note:* Phone numbers currently limited to US/Canada.

Get Started

3. The Operations Optimizer: Supercharge Your Internal Workflows

Boost internal efficiency and empower your team with an agent that streamlines content creation, research, and information management.

• What it does: Creates marketing materials, internal content, summaries, and reports based on your documents and internal knowledge base.
• Seamless Integrations: Adds files or connects with platforms like Google Drive, Notion, YouTube or OneDrive to access and process your existing content.
• Team Collaboration: Includes Slack integration for effortless information retrieval and team-wide access to AI-powered insights.

Get Started

Your Chipp Exec Journey: From Idea to Impact in Weeks

With Chipp Exec, you're not just getting an AI agent; you're getting a dedicated Gold Partner expert to guide you every step of the way. Our streamlined process ensures a smooth, efficient build, delivering your custom AI app ready to deploy within just 2-4 weeks, depending on scheduling.

Here’s how your journey unfolds:

• 1x Instruction Session: We kick things off by clearly defining your vision, requirements, and desired outcomes.
• 1x Iteration Point: Your expert builds the first draft, and you provide feedback for refinement and tweaks.
• 1x Offboarding Session: We hand over the project, ensuring you're confident and ready to take the reins of your new AI agent.
• 1x Check-in (4 weeks post hand-off): We'll follow up to ensure everything is running smoothly and answer any lingering questions.

Chipp Exec Investment

The Chipp Exec "Built-For-You" service is designed to be transparent and value-packed:

• $2000 per build project (refer to our build menu above for details).
• Plus, a Chipp plan is required to host your powerful new agent. You can explore our plans here: https://app.chipp.ai/plans
• Additional Deployments: Only $500 for each extra deployment beyond the one included in your build.
• Additional Agents: Want more AI power? Additional agents are $2,000 each.

Ready for something more complex? If your vision extends beyond our standard menu, no problem! Book a session with our team to scope out your unique project and get a custom quote.

Don't Get Stuck – Get Started!

The end of the year is the perfect time to implement those game-changing AI solutions you've been dreaming of. Don't let a lack of time or expertise hold you back. Let our Gold Partners build your AI app from idea to finished product in just 2-4 weeks.

Ready to transform your business with AI?

Purchase Your White-Glove AI Integration Package

This week, we're exploring the $400/year reality check that AI companies are facing, Gamma's lightning-fast product development powered by AI prototyping, and Andrej Karpathy's take on Software 2.0—the new rules for what AI can and can't automate.

On the Chipp side, **Scott sat down with Coffee with a Founder** to discuss democratizing AI and building outside Silicon Valley. We're breaking down **the AI Shopify moment** and why SMBs are about to leapfrog enterprises, plus insights from **Alfredo Narez's Chipp Con talk** on digital transformation that actually works. And if you haven't registered yet—**learn how to price and sell your AI products** in next week's workshop.

AI Highlights from Around the Web

The $400/Year AI Reality Check

Rex Salisbury breaks down what AI companies need to justify their massive investments: $400 per user per year by 2030. That's comparing AI to what Apple, Google, and Facebook make per user. JPMorgan Chase warns that lofty expectations often disappoint at first, even for world-changing tech.

Explore this tweet.

🌶️ The answer is right in front of us: ads are coming to AI. And that's actually a good thing. The recent chat with Eric Seufert on Stratechery (subscription required) showed all the ways ads will help everyone access the best models for free (or low cost). Look for AI to expand the potential value per perosn with new business models.

Gamma's Lightning-Fast Product Loop

Lenny Rachitsky shares how Gamma App has cracked the code on product development. Their secret? Build a prototype in the morning with AI, test it with 20 users that afternoon, collect feedback by end of day, and iterate (or kill) based on results. They do this for everything they build.

Explore this tweet

🌶️ Quick user feedback has long been a mantra for start-ups. Now quick is hours not days.

Software 2.0 and the New Rules of Automation

Andrej Karpathy shares a fascinating take on AI's economic impact. He thinks AI isn't like electricity or the industrial revolution. It's actually a completely new computing paradigm he calls Software 2.0. The old way (Software 1.0) automated tasks that followed fixed rules and steps. The new way (Software 2.0) automates anything you can verify or measure. If an AI can practice something over and over with clear success metrics, it'll get really good at it. That's why AI crushes math and coding but still struggles with creative, strategic work that needs real-world context and common sense.

Explore this tweet.

🌶️ Karpathy gives a no-hype framework for the type of software that will be built with AI. They key is verifiability. If you can verify a task was done correctly, the AI can do the task. The key will be finding what is "good" to teach the AI. Turns out we don't always know!

Chipp Updates

The Chipp Flipp: AI's Shopify Moment

SMBs are about to have better AI than enterprises, and we're building Chipp to make it happen. Scott's Chipp Con SC keynote breaks down why we're at an inflection point where small businesses have the advantage. Think about e-commerce before Shopify: big companies like Nike had world-class checkout experiences while small shops had janky PayPal links. Shopify flipped the pyramid. Now a three-person jewelry shop can have a better checkout than Nike.

We're at that exact moment with AI. Enterprises have the budgets, but they also have the baggage. You can move fast, deploy today, and give your customers the best AI experience in your industry. The updated Chipp Builder brings five major updates: Voice + Telephony, Video Generation via Veo, access to all top models, three levels of privacy plus SOC 2 Type 2 certification, and MCP support.

**Read the blog.**

How Coca-Cola, GA Tech, and Aspiring Rappers Leverage AI Voice with Alfredo Narez

Alfredo Narez brought the house down at Chipp Con SC with his talk "Creator Power. Structural Support. AI ENABLED." He unpacked how digital transformation and AI create real value when teams focus on people, collaboration, and practical improvements. From teaching AI to speak Spanglish to showing how enterprises like Coca-Cola use voice on Chipp to reach customers, Alfredo made AI feel accessible and actionable for everyone.

**Read the blog.**

Turn Your AI Agent Into Revenue

You've built your custom AI agent, so now the big question: how do you actually make money with it? If you haven't registered yet for our workshop next week, now's the time. Learn how to price your AI products confidently and discover how to sell them. This is the most-asked question in our community, and we're answering it live. **Register here.**

In October we hosted over 100 people in Greenville, SC to share how they are using Chipp and AI to build the future of business and work. View all talks here.

Meet Alfredo

Alfredo Narez is a pro at turning big ideas into practical actions.

With a background in tech, brand building, and digital transformation, Alfredo knows how to help teams get more done with less stress.

At Chipp Con SC, he shared lessons on how anyone can use AI and digital tools to make work easier, teams stronger, and creativity feel limitless.

He shared his journey from teaching an AI how to talk in "Spanglish" to how enterprises like Coca-Cola are using voice on Chipp to reach customers. Watch his talk below 👇

Creator Power. Structural Support. AI ENABLED - Alfredo Narezo, The PMF Academy | Chipp Con 2025

What Is “Digital Transformation” Anyway?

Alfredo kicked off by saying digital change isn’t a one-time event. It’s something you grow into, one improvement at a time. No need for big words or scary projects. Instead, he suggested, look for little ways tech can help every day, like getting rid of annoying tasks or making things run smoother.

Tiny Steps, Big Wins

You don’t need to flip a switch and change your whole company overnight. Alfredo encouraged finding just one repetitive task to automate, like sharing info between teams or fixing a clunky spreadsheet. Suddenly, your everyday work feels lighter.

Teamwork Makes the Dream Work With a Little Help from AI

One of Alfredo’s big messages was about teamwork. He showed how AI isn’t just for “techies”—it’s for bringing everyone together. Forget departments working on their own islands! When people share tools and talk to each other more (with a nudge from AI), work gets easier and ideas travel faster.

Sharing is Caring

Alfredo made it clear that teams who talk, share wins, and learn together have more fun and get better results. All it takes is one leader being open to new tools and suddenly everyone feels safe to pitch in and try new things.

Real People, Real Problems, Real Solutions

Throughout the session, Alfredo kept coming back to a simple point: AI is here to solve problems, not create more of them.

Saving Time for What Matters

He showed how everyday folks can use AI to sort emails, answer basic questions, or put reports together in minutes. That means less time stressing over little things, and more time for the stuff you actually love like helping customers or brainstorming new ideas.

Tools for All

No manual required! Alfredo pointed out that most AI tools are now designed so anyone can use them, whether you code or not. If you can use your favorite apps, you can start making AI your work buddy.

Good Leaders Make Change Less Daunting

Alfredo talked about the people side of trying new things. Great leaders, he said, don’t just talk about new tech. They jump in and try it themselves even if things get a bit messy at first. And they keep everyone in the loop so nobody feels left behind.

Try, Learn, Share

It’s not about getting everything right on the first try. Alfredo says it’s okay to ask questions, make mistakes, and keep learning as a team. That’s when real, exciting change actually happens.

Learning is a Journey, Not Homework

AI changes fast, but Alfredo made it feel less intimidating. He recommended picking small, fun ways to learn together like a five-minute demo, a quick team chat, or reading a helpful article during your coffee break.

You Don’t Have to Do It All At Once

Alfredo reminded us: nobody’s keeping score. Keep making small steps, support each other, and soon, new tech will feel like just another helpful part of your day.

Wrapping Up: AI is for Everyone

Alfredo’s big takeaway? Creator power and strong teamwork are possible for every industry and AI can help anyone, in any role, to work smarter and support each other. Start with small wins, stay open to learning, and invite everyone along for the ride.

The AI Inversion

Last week, Wharton released a report showing 75% of enterprises are seeing positive ROI from AI initiatives. That's the headline everyone celebrated.

Here's what they missed: They surveyed companies with over $50m in revenue and 1000+ employees.

This is typically how technology adoption goes. Enterprises take the building blocks - technology, data, APIs - and customize them into complex solutions. The rest of us are left using standardized tools built for everyone, which meant they were perfect for no one.

But eventually a inflection point happens. The pyramid is about to flip in AI.

The Chipp Flipp: Your Shopify Moment

Think about e-commerce before Shopify.

Previously, if you were Nike, you could build a world-class checkout experience. You had developers, infrastructure, decades of institutional knowledge. If you were my wife running a jewelry shop in downtown Fargo with a team of three, you had a janky PayPal link and hope.

Shopify flipped it. Suddenly the three-person jewelry shop could have a better checkout experience than Nike. Why? No legacy tech debt. No thousands of SKUs to migrate. No decades of integrations to maintain. Just focus, agility, and the best tools available to anyone.

Small became an advantage. We're at that exact moment with AI.

Enterprises have the budgets, but they also have the baggage. Decades of systems that don't talk to each other. Compliance layers built on compliance layers. Committees that need to approve every decision. The Wharton report highlights this as the larger enterprises have slower adoption than smaller enterprises.

You don't have any of that. You can move fast. You can deploy today. You can give your customers the best AI experience in your industry before any Fortune 500 figures out which committee needs to approve the pilot program.

The thing holding you back was that the "Shopify" of the AI age had yet to emerge. Until now - that is the Chipp Flipp.

*Want to go deeper on the Chipp Flipp? Listen to the **full keynote** from Chipp Con: SC:*

The Year of AI Agency: Building Brand-Native AI with Chipp v2 | Chipp Con 2025 in Greenville, SC

The Experience Advantage

Here's a stat that surprises everyone: Older people have higher success rates with AI than younger people.

This is the first time I can remember in the history of tech adoption that experience beats technical knowledge.

Why? Because knowing what to ask matters more than knowing how to code. Having the context to validate and judge the AI matters even more. If you've spent 20 years in hospitality, you know exactly what questions a guest will have at 2am. If you've been a teacher for a decade, you know how to guide someone to the answer without just giving it to them. If you've run a medical practice, you know what patients are terrified to ask their doctor.

Your expertise and your context is the competitive moat. AI just lets you scale it.

This makes you a powerful AI user but how do you give that same expertise and context to your customers? How do you let someone who doesn't know what questions to ask tap into your expertise? How do you deploy your knowledge at scale while controlling how it's shared, how it sounds, and how it represents your brand?

You need AI that's not just intelligent. You need AI that's native to your brand.

What Brand-Native AI Means

Brand-native AI is AI that looks, sounds, and shares like you.

Native to your brand. Not OpenAI's logo at the top. Not "Powered by ChatGPT" in the corner. Your company. Your colors. Your voice.

Native to your rules. Control who can access what information. Share proprietary research with members only. Give prospects just enough to get interested. Let employees see internal knowledge without exposing it to the world.

Native to your voice. A teacher who uses the Socratic method and won't just give you the answer. A hospitality agent that sounds warm and helpful, not robotic. A medical practice that speaks in plain language, not jargon that scares patients.

Native to your knowledge. There are three types of knowledge in AI: world knowledge (everything on the internet), company knowledge (your proprietary information), and personal knowledge (how you like to work). Brand-native AI lets you combine all three and deploy it exactly how you want.

When I talk to Don, he shares information filtered through his expertise, his personality, his judgment about what I need to know. That's how humans communicate. AI should work the same way.

When you have brand-native AI, something changes. You're not worried about it saying the wrong thing. You're not worried about it looking unprofessional. You're not worried about it sharing information you wanted to keep private. You're confident enough to actually deploy it.

The Updated Chipp Builder: Five Big Announcements

We built Chipp two years ago to solve a simple problem: People needed to build AI tools and charge for them.

We've grown up a lot since then.

70 million+ conversations. 18,000+ builders. Tools deployed in Slack, WhatsApp, websites, phone calls, even physical NFC stickers on stuffed animals in doctors' offices.

Today we're announcing the updated Chipp Builder. Five major updates that make brand-native AI easier to build and more powerful to deploy. Watch the highlights on YouTube.

1. Voice + Telephony

Every Chipp can now speak. Twelve different voices. Anyone can talk to your agent instead of typing.

More importantly: You get a real phone number. US and Canada to start. Anyone can call your agent and have a conversation. Your customer support line that never sleeps. Your therapy bot that's available at 3am. Your tutor that walks students through problems by voice.

Use cases are already wild. Consultants and coaches giving clients 24/7 access to guidance. Teachers creating voice tutors for students. Medical practices answering pre-surgery questions so nurses aren't overwhelmed.

My favorite: Kids who can't type fast enough. My ten-year-old daughter can talk to a voice agent and actually share what's on her mind. She told it about bullying at school—something she never mentioned to me. She can't type fast enough to have that conversation with a chat window. Voice unlocked it.

Voice isn't a nice-to-have. For some use cases, it's the only way that works.

2. Video Generation via Veo

Built-in video generation through Veo, powered by Google. Create up to eight-second videos from any prompt. Instagram reels on demand. Marketing material in seconds. Prototypes for client pitches.

It's functional and fun. You can build an agent that generates custom video content for your audience. A real estate agent showing property walkthroughs. A fitness coach demonstrating exercises. A marketing team spinning up social content without a production crew.

We didn't have "fun" as a vector on our positioning chart. But it matters. When something is fun, people actually use it.

3. Access to All Top Models

Here's the big one: ~25 models now available to every Chipp user. GPT-5. Opus 4.1. Gemini 2.5 Flash. Open source models.

Different models for different jobs. Fast models for real-time conversation. Deep reasoning models for complex reports. Long context models—we're talking 1 million tokens, which is 750,000 words, roughly ten novels worth of instructions you can give the AI before the conversation even starts.

Why does long context matter? Instead of uploading files for the AI to reference, you can paste entire documents directly into the system prompt. The AI has it immediately. No retrieval lag. Higher accuracy. Total control.

We thought hard about pricing tiers. Which plan gets which models? How much does video cost? What about voice?

Then we decided: Just give it all to everyone.

Every paid Chipp plan gets access to voice, video, and all models. Plans start at $29/month. You get built-in usage, and if you go over, you just pay for what you use.

You don't need to spend $299/month on ChatGPT Pro to access the best models. You don't need an enterprise contract. You pick the model that fits your use case. You pay for what you use. That's it.

This is how we bring software margins to service businesses.

4. Three Levels of Privacy + SOC 2 Type 2

If you're going to deploy brand-native AI, you need to trust it won't leak your information.

Three privacy levels, starting today:

Level 1: No training. Nothing you say on Chipp is used to train models. Ever. This has been true since day one. If you use ChatGPT, you need a paid plan and have to manually turn off training. Anthropic deletes your data after 30 days. Chipp never uses it. Easy.

Level 2: Zero Data Retention (ZDR). When you send a message to Gemini to get an answer, Google doesn't save it. No chat history on their servers. Your information passes through and disappears. If you need compliance, this matters.

Level 3: End-to-end encryption. Only the person you designate can see chat logs. For industries where compliance isn't optional, this is the unlock.

Also: As of two weeks ago, Chipp is SOC 2 Type 2 certified. We were monitored continuously for three months to ensure we follow security processes and document everything. When your IT person asks if Chipp is secure, the answer is yes. Visit trust.chipp.ai for details.

Security and privacy aren't blockers anymore. They're solved.

5. MCP (Model Context Protocol)

For the technical builders: Chipp now supports MCP.

Think of MCP as roads. Some are free, some you pay for, some are closed. MCP gives you access to every open road. Connect to HubSpot, Linear, Zapier, and dozens of other tools. Pull information from your CRM. Write back to it after a conversation.

"Update Scott's record to include the phone call we just had." Done.

If your tool doesn't support MCP yet, you can still connect via API. We have a client—a membership organization for car dealerships—that pulls live data from government APIs about pending legislation. Members ask, "What's the latest on the commerce subcommittee bill about dealerships?" and get the answer instantly, with sources.

AI isn't a tool anymore. It's a coworker. And coworkers use tools to get work done.

Easy AND Customizable

Most tools make you choose: easy or customizable. Not both.

ChatGPT is easy. Open the app, ask a question, get an answer. But it's standardized. You're on their platform. Their branding. Their rules. You can build a custom GPT, but sharing it is clunky and it still says OpenAI at the top.

n8n and similar workflow builders are powerful and customizable. But they're complex. Great for agencies. Overwhelming for most. And when something breaks in a long automation chain, good luck figuring out which node failed.

**Chipp is easy *and* customizable.**

One sentence builds an agent. "Create a conference guide for AI builders in Greenville that helps them find local spots and learn how to build tools." Sixty seconds later: full agent with a prompt, welcome message, logo, mobile app, and scraped knowledge from your website.

Out of the box, enjoy agents nearly as good as the agents our clients spend weeks building. You can tweak it from there, or just deploy it.

Once it's built, deploy anywhere: iframe on your website, chat widget, Slack, WhatsApp, phone number, progressive web app that lives on someone's phone like a native mobile app. Or go physical—NFC stickers that start a conversation when someone taps their phone.

We have a urologist client who gives patients a branded stuffed animal with an NFC sticker. Tap your phone to it, and a voice agent answers all your pre-surgery questions. Can I eat before the procedure? What should I bring? What time do I need to arrive? The nurse isn't overwhelmed with calls. The patient feels prepared.

Physical and digital together. Brand-native AI in the real world.

Get Started with Brand-Native AI

The updated Chipp Builder is now live. Try it today: chipp.ai

Over the coming days we will be showing you how to take advantage of these new superpowers. Subscribe to continue to learn

Join 18,000 Chippsters building brand-native AI: The tools are ready. The community is here. The only thing missing is you.

This week, we’re thinking about AI providing companies the chance to scale bottoms up - with individual users and trusted networks of supporters. This will help you improve your business - so you can worry less about human extinction and more about growth.

Plus, a couple of throwbacks worth revisiting: 👉 Learn how to bring **live data** straight into your AI workflows with Chipp + Zapier + Google Sheets 👉 See how our **Gold Partners at Purpose Driven AI** help teams co-build solutions that actually stick.

AI Highlights from Around the Web

Gamma's $2.1B Lesson in Going After the Right Users

Siddhartha Saxena shares one of tech's biggest plot twists. A year ago, Tome AI dominated the AI presentation space with 20M users. Today, Gamma just hit $100M ARR and a $2.1B valuation while Tome's site throws a 404 error. The difference? Gamma built for everyday users while Tome chased enterprise deals.

Explore this tweet.

🌶️ We are always full the tension between product-led growth and enterprise sales. The age of AI provides an opportunity to build for individuals and scale up to large orgs. Gamma did this better than most.

Speed Isn't Enough Anymore

Lenny Rachitsky points out the double-edged sword of AI development. Sure, AI makes building faster for everyone, but that means your competitors have the same advantage. Traditional growth channels like SEO and ads are getting crowded.

The winning move?

Build through ecosystems and partnerships. Companies like Gamma, Supabase, and Clay are growing by working with micro-influencers, power users, and trusted intermediaries instead of starting from zero.

Explore this tweet.

🌶️ Trust becomes more important in the Age of AI when we're not sure what is real. Brands who can build trusted networks can win. That's why we love our Chippsters! 🥳

AI's Fork in the Road

Neil Irwin shares a striking (and kind of insane) visualization showing two possible futures: AI either ends scarcity and boosts trend growth by 0.2 percentage points, or leads to tech singularity.

The chart maps US real GDP per capita on a log scale from 1870 to 2024, with projections splitting into dramatically different paths.

Explore this tweet.

🌶️ Chalk this up to 🤷 - I think as always it's somewhere in between so I'm betting on AI boosted growth. Plus, let's be stoic and control what we can control. Make your workflow and business more efficient first - worry about human extinction later.

Chipp Updates

How to Price and Sell Chipp

You've built your custom AI agent—now what? This workshop answers the most-asked question in our community: how do I actually make money with this? Join us to learn how to price your AI products and how to sell them with confidence. **Register here.**

Supercharge Your Lovable App with Chipp

Michael Kline shows you how to build smarter, more personalized AI assistants in your Lovable apps without any limitations. The tutorial covers how to integrate Chipp into Lovable, choose from multiple AI models like Claude, ChatGPT, or Gemini, and train your assistant using your own documents.

Check the tutorial.

Whether you’re a total no-coder, a seasoned vibe coder, or just tired of “one-size-fits-all” built-in AI, this tutorial will show you exactly how (and why) to plug Chipp into Lovable for maximum flexibility and fun.

Click here to watch on YouTube.

Integrating Chipp AI Assistants into Your Lovable Apps

What Is Chipp?

Chipp is a no-code AI assistant builder that lets anyone—no programming needed—create and train powerful, custom AI agents.

With Chipp, you can choose from all the best frontier models, including Gemini, Claude, ChatGPT, Mistral, and more, and tailor each assistant with your own documents, PDFs, and data.

What Is Lovable?

Lovable is a wildly user-friendly no-code platform for building and sharing custom apps—perfect for “vibe coders” who care more about results than writing code.

Their newest feature, Lovable Cloud, makes it easy to add database storage and baked-in AI to your app.

Why Use Chipp with Lovable (Instead of the Built-In AI)?

Lovable’s built-in AI (“Lovable AI”) uses Gemini. That’s solid—but what if you want:

• Your choice of models (Claude, ChatGPT, Gemini—even experiment with new ones)
• Deep, flexible training over your unique docs, PDFs, or websites
• More nuanced and domain-specific answers

With Chipp, you get all of that—and training is as simple as uploading your docs or connecting your app!

Click to watch the video 👇

Step-by-Step: Integrating Chipp with Lovable

1. Build & Train Your Chipp Agent

• Head to Chipp.ai and create your first agent.
• Name it whatever you want (our example: "Gladdy Knight"—school mascot vibes encouraged 😄).
• Upload knowledge sources—PDFs, web pages, or handbooks your assistant should know. (For instance, Mike Klein uploaded both English and Spanish versions of a school handbook for his ESL app.)
• Chipp scans the docs and your agent instantly knows all the context.

2. Prep Your Lovable App

• In Lovable, create or open your app project (works great for mobile/PWA).
• Enable Lovable Cloud—this brings powerful (but easy) database and backend features to your app. Perfect for non-coders, but robust enough for power-users.

3. Start the Integration Plan in Lovable

In Lovable’s chat/planner, announce you’re integrating a Chipp AI assistant via API.

Specify:

• *You want the assistant to live in a sliding drawer (or floating button), styled for your app*

The assistant should auto-detect user language and support multi-language conversations if needed

4. Provide Chipp API Key and Model ID

• Lovable will ask for your Chipp API Key and the specific Model ID (get these from your Chipp agent settings).
• Paste them into Lovable’s prompts.

5. Lovable Generates the Plan—Let It Cook

Lovable will run through setup questions, fetch the Chipp API documentation, and automatically generate edge functions and API calls for your app.

For most users, integration is done in minutes, with almost no manual coding.

6. Test It Out!

Your Chipp AI assistant should now appear as a floating action button or chat drawer in your Lovable app—ready to help your users, answer in their language, and impress with all the custom knowledge you trained into it.

Tweak the presentation and user experience to match your app’s vibe. 😎

Real-World Example: Solving for ESL Education

Mike Klein built an app for ESL (English as a Second Language) families, making school handbooks accessible in English and Spanish—*and* adding a Chipp-powered assistant trained on the handbook’s contents.

Result?

Families can get instant, reliable answers—no more digging through PDFs or waiting for translations.

Key Takeaways (Why You Want to Get Started with Lovable + Chipp)

• Total Freedom: Choose any AI model—no lock-in or limitations.
• Own Your Knowledge: Train assistants on YOUR data, not just public info.
• No-Code Simplicity: If you can point, click, and copy-paste, you can do this.
• Real Results: Practical, helpful apps used by real people, not just demos.

Ready to Build Your Smarter App?

Build your first Chipp agent now - it’s free to get started. Just visit Chipp.ai and tell Chipp what you want and in 60 seconds it's ready for you.

Vibe coding indeed.

This week, we’re zooming out to see how AI is reshaping work—from global adoption gaps to how businesses are using agents to tackle problems humans never could before. We look at what Jeff Bezos calls the “industrial bubble” of AI, explore new thinking on how to evaluate agents, and see what happens when automation makes intelligence on-demand.

Plus, a couple of throwbacks worth revisiting: 👉 Learn how to bring **live data** straight into your AI workflows with Chipp + Zapier + Google Sheets 👉 See how our **Gold Partners at Purpose Driven AI** help teams co-build solutions that actually stick.

AI Highlights from Around the Web

ChatGPT's E-commerce Performance: The Data is In

Mic King shares a major e-commerce study analyzing 973 sites with $20B in revenue. The verdict? LLMs *underperform* all other channels except paid social in conversion.

Explore this tweet.

🌶️ Behaviors are changing. I imagine conversion will soon be much higher in LLMs...but it's not there yet. Watch this space as we see how shopping behaviors change.

The Global AI Divide is Real

Brad Smith from Microsoft highlights a striking reality. AI is spreading faster than any technology in history, yet there's a clear divide in who's actually using it. Microsoft's AI Economy Institute's new AI Diffusion Report maps out where the world stands today and shows the steps needed to expand access, build skills, and make AI work for every language and community.

Explore this tweet.

🌶️ Access is different than adoption. We are seeing a technical divide due to adoption. The problem to solve is training, onboarding, and removing fear so people use the super intelligence waiting for their them. Agency is the new differentiator.

Agent Evals Need to Focus on Function Calls

Aaron Levie breaks down why agent evaluations need a complete rethink. Instead of judging agents by their answers, we should evaluate them by their function calls and decision-making. It's not about prose quality, it's about whether the agent knows when to escalate, when to fetch data, and when to admit it needs help

Explore this tweet.

🌶️ AI face the paradox of choice too! When AI can get information anywhere, it needs to get great at accessing the right information...just like humans! Think of building evals or improving this step for better AI agents.

Jeff Bezos on the ‘AI Bubble’

At Italian Tech Week 2025, Jeff Bezos embraced the hype—calling it an *industrial* bubble, not a financial one. “AI is real, and it’s going to transform every single industry,” he said. Sometimes, the so-called bubble is exactly what builds the future faster.

Explore this tweet.

🌶️ Both Bezos and Ben Thompson spoke of the importance of bubbles that create lasting value (think railroads, fiber for the internet, etc.) versus transiant value (think tulips or GPUs which go out of date quickly). For a truly transformational bubble, we need to build power - which will help us for generations no matter what we build.

Jevon’s Paradox and the Age of Cheap Intelligence

Jared Friedman and Aaron Levie remind us that when intelligence gets cheaper, we use more of it. Levie predicts that 95% of AI tokens in five years will go to tasks humans never did before, unlocking whole new categories of work that once seemed impossible.

Explore this tweet.

🌶️ We see the same thing at Chipp. When we have better AI tools, people want to use it more. As prices drop, people use AI more. Finding new problems that we never considered will be a big area of opportunity for businesses.

Chipp Updates

Supercharge Chipp With Live Data: Bring Dynamic Info From Anywhere Into Your AI Agent

What if your Chipp AI could do more than just chat—it could *act* on live data? With Chipp, Zapier, and Google Sheets, you can automate signups, log leads, manage projects, and sync info across your workflows. This tutorial shows you how to make your AI assistant a true business teammate. Check the full article.

How Sprint-Driven, Co-Built AI Unlocks Real Results

Our Gold Partners at Purpose Driven AI are showing how co-building beats complexity. Through rapid AI sprints, they help teams design, test, and deploy real solutions—together. It’s a no-nonsense, purpose-first way to make AI adoption natural and effective. Check the full article..

With Chipp’s ability to connect to any datasource using Zapier and Google Sheets, you can empower your agent to become a true business teammate, not just a chatbot.

Use Case Inspiration: What Can You Build With Chipp + Live Data?

• Event Planning: Collect ideas for community events, track RSVPs, and manage attendee lists automatically.
• Lead Collection & Sales: Capture leads from website forms or chat, route info to your CRM, and have your agent visualize or follow up instantly.
• Task & Project Management: Log feature requests or tasks from conversations and sync with project boards like Trello or Asana.
• Content Brainstorming: Gather blog post suggestions from staff or users, send them to a spreadsheet, and let your agent showcase or prioritize the best ideas.
• Customer Support & Feedback: Save customer tickets, feedback, or bug reports in real time for your support or product team.
• Member Engagement: Track user activity, preferences, or poll responses across platforms and let Chipp personalize messages or updates.
• Resource Curation: Auto-update links, reading lists, or curated resources that your Chipp agent can present on demand.
• Operational Dashboards: Have Chipp fetch the latest metrics, inventory numbers, or scheduling info right from Sheets to any chat or workflow.
• Education & Tutoring: Log student submissions or questions in a sheet and let your agent provide tailored tips or progress tracking.

These are just starting points—if you can get it into a spreadsheet, you can make Chipp work for it!

How to Bring Data into Chipp from Any Datasource: Step-by-Step Guide

How to Bring Data into Chipp from Any Data Source

Watch the whole tutorial above, or run step-by-step below. 💪

Step 1: Understand Your Use Case

This workflow is demonstrated for a community management scenario, such as generating ideas for community events.

• The flow: Use Chipp to generate ideas, send those ideas to Zapier for enhancement, and store everything in Google Sheets. Then, test retrieving these ideas back into Chipp.

Step 2: Set Up Your Prompt in Chipp

1. Create a Prompt:Use a prompt generator to describe what you want Chipp to do (e.g., “generate event ideas and store them”).Generate and save this prompt inside Chipp.
2. Use a prompt generator to describe what you want Chipp to do (e.g., “generate event ideas and store them”).
3. Generate and save this prompt inside Chipp.

Step 3: Configure Zapier

1. Set Up a Zap with Catch Hook:In Zapier, create a Zap using the “Catch Hook” trigger.This allows Chipp to send data to Zapier.
2. In Zapier, create a Zap using the “Catch Hook” trigger.
3. This allows Chipp to send data to Zapier.
4. Test the Zap:After setting up the Catch Hook, perform a test from Chipp to make sure Zapier receives the data.Copy the Catch Hook URL that Zapier provides; you’ll need it for the next step.
5. After setting up the Catch Hook, perform a test from Chipp to make sure Zapier receives the data.
6. Copy the Catch Hook URL that Zapier provides; you’ll need it for the next step.

Step 4: Integrate Chipp with Zapier

1. Create a Custom Action in Chipp:Go to the section in Chipp for defining custom actions.Click “Add Custom Action.”Fill out the following details:Title and description for your custom action.Paste in the Zapier Catch Hook URL.Set the method to “POST.”No need for a path or query parameters at this stage.Define body parameters if needed.
2. Go to the section in Chipp for defining custom actions.
3. Click “Add Custom Action.”
4. Fill out the following details:Title and description for your custom action.Paste in the Zapier Catch Hook URL.Set the method to “POST.”No need for a path or query parameters at this stage.Define body parameters if needed.
5. Title and description for your custom action.
6. Paste in the Zapier Catch Hook URL.
7. Set the method to “POST.”
8. No need for a path or query parameters at this stage.
9. Define body parameters if needed.

Step 5: Use Google Sheets as Your Data Store

• Inside Zapier, set up an action to take the data received from Chipp and add it to Google Sheets.
• Use Zapier to enrich/process data as you wish between Chipp and Sheets.

Step 6: Test Retrieval from Google Sheets to Chipp

• Run a test to ensure you can pull (retrieve) information from Google Sheets back into your Chipp app. We like to use Sheety to make it even easier.
• Check that the integration allows for smooth data fetching from Sheets into Chipp.

Learn By Watching

Want to see the workflow in real time?

Watch the full tutorial on YouTube for a step-by-step demo of every click and option.

Chipp makes it simple to bring your live data into every conversation and workflow. What will YOU build next?

Why does this happen? Because org charts are static blueprints, while organizations are dynamic, living systems. As I like to put it, “as soon as you print it, it’s out of date.” People change roles, projects form and dissolve, and responsibilities are quietly accumulated or let go. The chart, meanwhile, stays frozen in time—a snapshot, not a living map.

The Real (Invisible) Organization

Org charts usually plot a single manager for every employee, cleanly sorted into hierarchy. But real life is much more interesting: a network of overlapping roles, informal collaborations, and hidden lines of communication.

I often begin engagements by looking at an official org chart—boxes, colors, formal titles neatly arranged. Then, I’ll ask simple questions:

• “If something breaks and needs fixing today, who gets the call?”
• “When a new opportunity comes up, who rallies the team or takes the initiative?”
• “Whose input do people secretly trust, even if they aren’t on the leadership team?”

The list that comes back is rarely what the chart would have predicted. Relationships, reputation, trust, and chance encounters shape the actual flow of work and influence. There are often key people who act as the informal “glue”—the connectors, mentors, and troubleshooters nobody thought to put in their formal job description.

You can’t see this with boxes and lines. The org chart doesn’t record trust, grit, or those moments in the hallway where truly important conversations happen.

What Leaders Actually Need to Know

The most effective leaders I’ve worked with share a curiosity about these invisible networks. Instead of simply defending the chart, they ask:

• Who are the informal connectors—those through whom information, support, and feedback reliably flow?
• Where do real decisions happen—sometimes far from the “formal” decision-maker?
• Which workloads, projects, or relationships are only held together by a few irreplaceable people? What happens if those people leave or burn out?
• Are there isolated teams or individuals who could contribute more—if only the organization’s wiring better supported them?

These are questions an org chart won’t answer. But ignoring them means missing vital signals about organizational health and resilience.

How AI Fills the Gap

This is where modern tools, including AI, can dramatically help—not by replacing managers’ judgment, but by providing another lens.

By examining real-world patterns—in communication (again, with respect for employee privacy), in project collaboration, in how and where people offer support—AI can reveal:

• Central nodes in your network: those people who consistently connect others and solve problems.
• Bottlenecks: places where approvals or resources get stuck.
• Unseen talent: people whose contributions deserve more recognition or responsibility.

Instead of a single, fixed chart, you gain a living map that evolves with your team.

Chipp and similar tools make this work accessible. You can filter views—seeing work networks, social connections, or points of vulnerability—all as living data, not one-off charts.

This doesn’t replace your org chart; it complements it. The org chart and the network view together let you see both intended structure and emergent reality.

Practical Steps and Reflections

If you’re serious about organizational effectiveness, start small:

• Notice when the results you count on aren’t coming from where the chart suggests.
• Invite employees to map their own networks—ask, “Who do you turn to when you need help?”
• Try simple network analysis (or, if you’re ready, AI-driven tools like Chipp) to visualize hidden strengths and vulnerabilities.

The greatest competitive advantage isn’t in what’s official, but in what actually works—so keep searching for it, measuring it, and above all, supporting it.

Want to go deeper?

Watch the whole session recording below.

Your Org Chart is Lying to You – Session Recording

And if you want partnership—whether to map your organization's real dynamics, develop a network perspective, or thoughtfully implement AI—I’m happy to talk.

Multi-agent systems aren’t just AI buzz—they’re game-changing for education, business, and community projects. Here’s what’s possible when you combine Chipp (no-code AI agent builder) and Make (automation platform):

• Virtual Teaching Assistants: Coordinate personalized help for students using specialized sub-agents (for lectures, predictions, and engagement).
• Lecture Assistant Agents: Instantly tag, organize, and deliver complex educational content for teachers and learners.
• Predictive Modeling Agents: Bring data-driven insights into courses, dynamically generating analysis based on historical data.
• Student Engagement Assistants: Keep learners motivated, involved, and excited with tailored AI-driven interactions.

With these workflows, you can orchestrate a team of AIs that work together—no code required!

🛠 Step-by-Step: Build Your Multi-Agent System with Chipp & Make

Prerequisites

• Free accounts on Chipp.ai and Make.com
• An idea or problem to solve (e.g., deliver classroom lectures, analyze data, engage students)
• Basic understanding of the information your agents will interact with (documents, questions, data sources, etc.)

How to Create Multi-Agent Systems with Chipp & Make

1. Plan and Define Your Agents (Brainstorm & Role Assignment)

Goal: Map your "team" of AI agents, assigning each a clear, single-purpose job.

Example:

• Lecture Agent: Answers factual questions and provides educational content.
• Predictive Agent: Analyzes data, makes predictions, or summarizes trends.
• Engagement Agent: Checks in with users, asks probing questions, or suggests extra resources.

How-To:

• Write down your user journey (e.g., “A student asks a question about history, the system delivers a fact, predicts future exam topics, and offers interactive follow-up.”)
• For each part, assign a single agent: “Who handles this? What’s their role?”

2. Build Each Agent Separately in Chipp

a. Create Your First Agent (e.g., the Lecture Agent)

• Go to Chipp.ai
• Click “New Agent”
• Fill in:Agent Name: (e.g., “LectureBot”)Role/Purpose: “Delivers concise and referenced answers to subject-specific questions.”Prompt/instructions: Be specific (“When someone asks about a historical event, give a 2–3 sentence summary, provide a citation, and an engaging follow-up question.”)
• Agent Name: (e.g., “LectureBot”)
• Role/Purpose: “Delivers concise and referenced answers to subject-specific questions.”
• Prompt/instructions: Be specific (“When someone asks about a historical event, give a 2–3 sentence summary, provide a citation, and an engaging follow-up question.”)
• Optionally: Add a Knowledge Base (upload lecture notes, docs, or link resources)
• Test with a question (e.g., “What started World War I?”)

b. Repeat for Other Agents

• PredictiveBot: “Analyzes grade trends and predicts student progress based on sample data.”
• EngagementBot: “Keeps students motivated by asking reflection questions and sharing motivational quotes.”

Tip: Each agent should ONLY focus on its unique function.

3. Set Up Your Multi-Agent Workflow in Make

What you’ll do: Stitch your agents into a pipeline/workflow.

a. Connect Chipp Agents with Make

• In Chipp, for each agent, click “Integrations” or “API” to create an API key/endpoint (copy these for Make)
• In Make.com, click “Create a new scenario”
• Add a trigger (e.g., “Watch for new question from user” via webhook, Google Form, or chat widget)

b. Add Chipp Modules to Make Scenario

• Search for “HTTP” in Make and select “Make a request” (since direct Chipp integration might be via HTTP/Webhook)
• For each agent:Add a module calling that agent’s endpointPass user’s question, or the output of the previous agent as “input” to the next (e.g., user’s question → LectureBot → answer feeds into PredictiveBot)
• Add a module calling that agent’s endpoint
• Pass user’s question, or the output of the previous agent as “input” to the next (e.g., user’s question → LectureBot → answer feeds into PredictiveBot)

c. Configure Data Routing and Formatting

• Use Make’s “Set variable” or “Text aggregator” modules to combine, format, or separate responses
• Example:New question receivedRoute to LectureBot (get answer)Send same (or modified) query + context to PredictiveBot (get prediction)Send both outputs (possibly as a single string) to EngagementBot (get motivational follow-up)
• New question received
• Route to LectureBot (get answer)
• Send same (or modified) query + context to PredictiveBot (get prediction)
• Send both outputs (possibly as a single string) to EngagementBot (get motivational follow-up)

d. Output to End User

• Choose how your final output is delivered (e.g., via chat, email, dashboard, or a Google Doc)
• In Make, add a module to send this message back to the user (e.g., via webhook response, Gmail, Slack, etc.)

Visual Example:

[User Q] → [Lecture Agent] → [Predictive Agent] → [Engagement Agent] → [Response to User]

4. Test and Refine Your System

• In your Make scenario, run a test (“Run Once”)
• Enter a sample question
• Watch the full sequence:LectureBot reply?Predictive insight delivered?Engagement message added?
• LectureBot reply?
• Predictive insight delivered?
• Engagement message added?
• Check for clarity, timing, and relevance of each piece.
• Adjust any agent's instructions (in Chipp) or the data flow (in Make) for improvements.

5. Automate and Share

• Once it works as intended, set your Make scenario to “ON” (live automation).
• Share your input link with students, colleagues, or test users.
• Monitor usage (via Chipp chat logs or Make scenario logs) and refine as needed:Are users getting helpful responses?Does each agent add value?Is follow-up engaging?
• Are users getting helpful responses?
• Does each agent add value?
• Is follow-up engaging?

🔥 Advanced Tips

• Use Chipp’s “Knowledge Grounding” to keep answers referenced and accurate—especially for education!
• Add branching in Make: route specific topics to specialized agents.
• Set up analytics to see which agent contributes the most value.

💡 Key Tips & Insights

• Tag and organize all agent outputs for easy retrieval—especially with lecture or content-heavy use cases
• Use Make’s logic tools to route questions or escalate complex queries to human instructors if AI agents can’t handle them
• Keep engagement agents “human”—add prompts for encouragement, polls, or quick feedback to students
• Always test your workflow with real end users for best results

🎬 Watch the Full Video

For the complete walkthrough, visual aids, and more inspiration, check out the source video: ▶️ Multi-Agent Systems with Chipp & Make (YouTube)

This is a Gold Partner feature. Our Gold Partners integrate Chipp for clients. They bring industry expertise and unique perspectives on the future of AI.

Why We Sprint: The Real Secret to AI Success

Let’s be honest: the tech is rarely the problem. In every organization—startup, small business, or global enterprise—brilliant AI initiatives get stuck because people aren’t truly part of the build. Features are developed in isolation, “change management” gets bolted on at the end, and internal expertise gets left out.

Luckily there's another way.

Maaria Tiensivu* (Service Designer, Transformational Coach, and Chipp Gold Partner)* and Josué Citalán *(a lawyer and AI governance expert)*, the co-founders of Purpose Driven AI are all about co-building with intention.

*"Every sprint, every AI tool, every engagement is designed to bring out the best from your people and deliver solutions that genuinely work in the real world." *– Maaria Tiensivu

That’s why they run AI Co-Build Sprints: rapid, collaborative, no-nonsense cycles designed to unlock what works. These sprints don’t just build better AI—they mobilize internal expertise, turn knowledge into action, and produce a group of ambassadors who make adoption inevitable.

***When you build WITH your people, not just FOR them, you get solutions nobody else could.* **(Also, including the right people makes implementation the natural next step, not a fight.)

Co-Build Sprints at a Glance 👀

0️⃣ Scan & Align: Clarify what matters most, using playful but powerful entry scans. Either purpose-driven or role-based.

1️⃣ Map & Discover: Explore the entire customer and workflow journey as a group. This is where the “aha!” happens: surfacing the knowledge no one has written down, the tricks and workarounds the best people use, and the pitfalls new hires always stumble over. You’re uncovering the “gold dust” inside your organization—the kind of experiential know-how you can’t Google.

2️⃣ Focus & Design: Sharpen your priorities as a group. Decide what makes this solution special and where each participant should focus.

3️⃣ Build Together: Co-create AI solutions and agent prompts. The best-performing “prompt engineering” happens with real experts—side by side with your builder, not just the AI person.

4️⃣ Test & Reflect: Collect fast feedback from your humans and AI. Iterate live.

5️⃣ Implement & Grow: Codify what works, draft agreements, and—crucially—train your own internal champions so roll-out is smooth and sticky.

Want to see sprints in action? Watch Maaria on YouTube.

How to Build Intentional AI Solutions in 5 -Steps!

1. The “Co-Build Sprint” Approach

Instead of long, drawn-out projects with unclear owners, Purpose Driven AI runs tight, focused co-build sprints, each with clear goals and collective energy. Each step is engineered for results and real results—never pointless process.

What happens after a sprint? After a sprint, it's remarkably easier to make calls about big AI projects.

Why? You’ve built your team of internal advocates. AKA people who have co-created, tested, and “tried on” the solution. They’re invested. They’re ready. They’ll drive adoption organically and help implement change.

Maaria Tiensivu puts it best:

"I've run sprints for years, but this is the first time we can actually BUILD solutions your team can implement after just five sessions. With our chipp.ai powered sprints, anyone can join—not just technical people. The first sprint wont's solve your AI strategy, but it's the spark. Once you start, there’s no stopping. That's how you get exponential value with the smallest tech investment you've probably ever made..."

Want to get your own sprint?

Book a Call to Get Started

2. Who Sprints, Makes the Difference

This is where projects miss the mark. It’s almost never about the framework or the tool"—it’s about who you put in the sprint.

Here’s the test: Who should be in the sprint? Ask yourself: *“If [insert name] left the team, we’d be in big trouble...”* That’s who you need at the table.

—Small businesses: it might be your founder, your one real customer-whisperer, or that person who just “gets” your process. —Big organizations: think beyond the “usual suspects.” Find the quiet process owner, the troubleshooting expert, the salesperson everyone trusts. If someone carries unique knowledge in their head, make sure they’re in the sprint. Otherwise, it’ll never be captured.

The magic 🪄 When you intentionally bring these people in, their wisdom finally gets unlocked, shared, and embedded directly into the AI solution. They also become your post-sprint change agents.

3. Built-in Purpose and Testing

Forget “bug hunting.” What actually matters is discovering where the true challenges are, and building to solve real problems. Each sprint creates a safe space to test your ideas and assumptions right away with real humans.

The result: You get honest, actionable feedback from the actual people who'll use or be impacted by the solution. This insight lets your team improve, pivot, and perfect your AI—fast.

*“Testing isn’t just about finding bugs—it’s about revealing where your solution truly provides value, and how someone who thinks completely differently from you might use it (for good, or evil *👹*).”*

Why It Works

This isn’t just faster or fancier—it’s how real change happens. Sprints force honest conversations, unlock hidden expertise, and install change agents from day one.

*The AI you build isn’t an outsider’s guess with a steep pricetag.*

It’s built by your people, shaped by your unique culture, and ready for impact because the right humans shaped it from the start.

By the end, you don’t just get a “solution.” You get a better way of working together, a new team of internal evangelists, and a living set of best practices built-for-you and by you. 💪

The Sprint Toolkit—Your Quick Start

No matter your org size, you can start small and scale. Want to get started? See the steps in action:

Try out the AI Suite: Purpose Driven AI HQ (Join here)

Watch Maaria’s full live walkthrough: YouTube

Ready to Sprint (and Never Look Back 👀)?

• Get inspired by the source Watch Maaria’s YouTube breakdown
• Experience it with your own team? Join the Purpose Driven AI HQ and try it hands-on
• Ready to run your own sprint? Book a call with Maaria to make the change

*“If you want lasting change and great AI, don’t go it alone—co-build with the people who matter.” – Maaria Tiensivu*

Our speakers, Don Barger (Director of Innovation and AI at the International Mission Board) and James from Biblica, shared insights from their real-world experience using AI in faith-based organizations.

Watch the full workshop recap below:

If you missed the live session or want to revisit the conversation, here are the biggest takeaways that can help your church or ministry start using AI thoughtfully and effectively.

AI for Churches: Empowering Ministry in the Digital Age

AI Ideas from Attendees

We kicked off this session asking attendees for how they're integrating AI. Here were some of the top ideas:

• Building AI agents to help staff and volunteers access organizational knowledge
• Daily phone call agents with agenda management for elderly parents
• Creating sermon presentation slides
• Bible study tools with concordance and translation features
• Generating Sunday school coloring sheets
• Linking scripture to original Hebrew and Greek texts
• Multi-agent tools for ministry client management
• Building custom dashboards in BI tools
• Strategic planning assistance
• Developing business case strategies for AI implementation

The Faith Bot Story: From Small Group Question to 150,000+ Users

Don Barger shared how Faith Bot started from a simple moment in his church small group. When the leader said something theologically questionable, Don quietly checked it using an AI tool he'd been building. After the meeting, he gave the leader an NFC card that opened Faith Bot, a chatbot that answers faith questions grounded in scripture.

The growth was unexpected. After giving out 150-200 cards at a conference, they had 3,000-4,000 users by week's end. Today, Faith Bot has over 150,000 users across dozens of languages, from English and Spanish to Burmese and Shona.

The key insight? The best AI tools solve simple, real problems. Don wasn't trying to build something massive, just help his small group leader teach with confidence.

Breaking Down Language Barriers: Biblica's Journey

James from Biblica explained how quality Bible study resources can cost $60-100 and are often only in English. That's a huge barrier for pastors in places like Cairo or Cape Town.

Biblica created study notes at a third-grade reading level, released them in Creative Commons, and built AI chatbots trained on these materials. They launched in English, Spanish, and Hindi just one week before today's workshop.

The results? Over 20,000 conversations in the first week.

What made this work:

• Keep it focused: Built specifically for Bible study, nothing else
• Short responses: 5-10 sentences instead of long paragraphs
• Use your own content: Pulls from Biblica's translations, not random internet sources
• Launch and learn: "It doesn't have to be perfect," James said. Real user feedback beats months of perfectionism.

Understanding AI Privacy Without Getting Technical

Scott walked us through four levels of privacy protection:

Level 1: Turn off training - Make sure your AI provider isn't using your data to train future models. With Chipp, it's off by default.

Level 2: Zero data retention - Some providers (like Anthropic) automatically delete your data after 30 days. Others like Google can ensure your data is never saved. This is available on the Chipp Business Plan.

Level 3: Private infrastructure - Applications like Chipp can be deployed into an organization's cloud. This gives the IT team more control and separates the data from other users. With this level, users still use public models from OpenAI or Google.

Level 4: Fully private AI - Organizations can choose a completely private model that never sends data outside their environment. Both Don and James do just this. They work with Chipp and their partner Prediction Guard. With this privacy level, the model itself runs in your cloud and is an open-source model (which counter-intuitively means it is more private).

Real Church Applications That Are Working Today

Don shared tools from his Church HQ bundle that churches are actually using:

Sermon Research Pro helps pastors explore where their topic appears in the Bible and test their thinking, without writing sermons for them.

Engaged Lostness Series creates personas so you can practice sharing your faith with people from different religious backgrounds.

Faith Bot is being printed on NFC cards and handed out at events so people can ask faith questions anytime.

Other applications mentioned: conference chatbots, grant writing assistance, church planter vetting tools, and legislative tracking for advocacy organizations.

How to Get Started Even If You're Not Tech-Savvy

Our speakers shared some good advice:

1. Start with one specific problem - Don't build a "do everything" AI. Create one specialized tool that does one thing excellently.
2. Use examples, not just instructions - Show the AI good and bad responses. It learns better from examples.
3. Test it by trying to break it - James asks ChatGPT to generate questions designed to break his chatbot.
4. Hard-code sensitive responses - For topics like self-harm or doctrinal questions, don't let the AI improvise.
5. Be willing to fail - Don emphasized that innovation requires trying things and learning what works.
6. Monitor conversations at first - Use tags in Chipp to flag sensitive topics so you can review responses.

Will AI Take Jobs?

AI will take some jobs, but he provided important context. Sixty percent of jobs today didn't exist in 1940. Technology has always caused shifts in the job market.

AI excels at repetitive tasks, processing large amounts of information, and filtering data. However, it falls short in areas like pastoral care, spiritual discernment, creative teaching, and building authentic relationships.

Don offered a helpful comparison. Just as a pen is a tool that can be used for good or harm, AI is simply a technology. The responsibility lies in using it ethically and intentionally.

Building Trust in Your Congregation

Don and James emphasized starting small and letting people experience it firsthand. When someone uses Faith Bot to get a helpful answer, they think about its usefulness rather than feeling scared of the technology.

James mentioned getting leadership buy-in at Biblica was crucial before public launch. The key is showing, not telling. Let people try something practical, then expand as trust builds.

The Voice AI Revolution

At the end of the workshop, Scott demoed Chipp's new voice feature. Now you can speak to Faith Bot on the phone or website instead of typing. Natural conversation, no robotic pauses, responses grounded in scripture. This feature launched today.

Your Turn: Getting Started with AI in Ministry

Ready to explore AI for your church? Here are your next steps:

1. Try Faith Bot yourself
2. Identify one specific problem in your ministry
3. Sign up for Chipp (free for your first 1,000 chats)
4. Test with a small group before rolling out widely
5. Learn from feedback and iterate

The churches seeing success aren't waiting for perfect understanding. They're starting small, learning as they go, and letting real ministry needs guide their strategy.

Join Us for More AI Insights

Want to stay updated on how churches and ministries are using AI effectively? We share workshops like this one, practical tutorials, and the latest AI news relevant to ministry work.

Subscribe to our blog to get recaps, lessons, and strategies delivered to your inbox. Whether you're just getting started with AI or already building tools, we're here to help you use technology to amplify your mission without losing the human heart of ministry.

Plus, we're helping churches bring AI into ministry with our **AI for Churches virtual event**, and we've achieved **SOC 2 Type II certification** to prove our commitment to keeping your data safe and secure, and we're hosting a working session on **how AI can help leaders see their organizations more clearly** and close the gap between how work is designed and how it actually flows.

AI Highlights from Around the Web

Why Most Companies Miss the Mark with AI

Mayank Vora breaks down a striking McKinsey stat: while 80% of companies now use AI, only 1% are doing it well. Many bought tools but never built real workflows around them. The real winners are those who rewired their organizations by rethinking systems, retraining teams, and making AI part of how they actually work.

Explore this tweet.

🌶️ Adding a tool doesn't work without complementary processes. Companies that add AI and rethink their processes will get the biggest impact. Our session on the future of org charts will talk directly on this next Thursday.

Everyone Should be Using Claude Code More

Claude Code isn’t just for developers. It’s like having a smart local helper that can tidy up your files, brainstorm new ideas, summarize meetings, or even edit images all on your computer. The post reminds us that AI doesn’t need to feel distant or technical. It can simply be a smarter way to get everyday work done.

Explore this tweet.

🌶️ Claude Code is scary for us non-technical folks...but it's amazing when the AI can find files on your computer. The unlock for me came when I integrated Obsidian with Claude Code, so everything it creates I get as a file and every file I make it can understand and edit.

AI Is Speeding Up Science

A new study shows that researchers using AI tools like ChatGPT are publishing more and better work. Productivity among GenAI users grew 15% in 2023 and jumped to 36% in 2024, with quality also rising. It's a clear sign that AI isn't just helping us work faster, it's helping us think better.

Explore this tweet.

🌶️ We're in a frog in boiling water situation - the amazing progress happening is almost invisible to us...but it's happening! Progress is accelerating and doesn't look to speed up.

Chipp Updates

Chipp Highlights and Events

Chipp is SOC 2 Type II Certified

We're proud to announce that Chipp has achieved SOC 2 Type II certification. This means an independent auditor has verified that our security controls work effectively over time to protect your data.

SOC 2 Type II opens doors for enterprise teams, healthcare organizations, educational institutions, and anyone who needs verified data protection. It also sets the foundation for HIPAA and FERPA compliance, which we're already working on.

**Read the announcement.**

AI for Churches: Empowering Ministry in the Digital Age

Technology is changing how churches connect, serve, and grow. We're hosting a free virtual event to explore how AI can help your ministry reach more people, deepen relationships, and free up time for what matters most.

Join us on October 21st at 11:00 AM Central Time for conversations with Don Barger (Director of Innovation and AI at IMB) and James Cuthbert from Biblica. They'll share real stories of churches using AI thoughtfully, and show you how to build custom tools that reflect your congregation's unique mission and values.

Your Org Chart Is Lying to You

Your org chart looks clean and tidy. But it doesn't show how work really happens. That gap between how your organization is designed and how work actually flows creates real risks: missed opportunities, stalled decisions, frustrated teams, and AI pilots that never scale.

Join Bob Gower on Thursday, October 23rd from 12:00-1:00 PM ET for a free working session: Leading in the Age of AI. You'll get a simple lens to see where your real bottlenecks live, three experiments you can run in the next 30 days, and a fresh view of AI as a leadership tool.

**Register for the event here.**

Chipp Con SC - See you in Greenville!

We're heading to South Carolina! Join us for a day of live demos and inspiring with the Chipp team and builders from across the country.

When: October 30, 2025 Where: Flywheel Coworking, Greenville, SC What's Happening: Get hands-on with new features, learn from AI experts, and connect with fellow builders who are pushing the limits of what's possible with AI

This is your chance to experience Chipp Con live. We'll see you there!

**Register here.**

Show me your org chart and I’ll show you a lie.

Not a malicious lie. Just an outdated picture that lodges in leaders’ heads and quietly misleads decisions. The moment it’s exported to PDF, it’s wrong—and it never showed how work really happens anyway.

That false certainty leaves you blind to growing risks.

The Faulty Operating Model

On paper you see clean lines and tidy decision paths. In practice your teams run on shadow workflows, informal influence, and now—AI tools your formal structure never anticipated.

That gap between how your org is designed and how work actually flows doesn’t just create inefficiency. It creates vulnerabilities that surface when:

• A competitor makes a move you should have seen coming
• Teams wait on decisions that should be obvious
• Your best people get frustrated and leave
• AI pilots stall or never scale

**The problem isn’t your people or your strategy. It’s the *operating model***—symbolized by that neat little org chart that’s built for a slower, more predictable world.

Think about a state change in physics. Water boils and becomes steam. The same molecules, but different behavior requiring different equipment.

Markets, culture, and technology (AI especially) have boiled. Old ways of structuring teams, making decisions, and managing work can’t contain this new state.

The good news: there’s a path forward.

If you treat this as a fundamental shift in how work gets done, you can turn disruption into advantage. AI helps—not as a robot to replace people, but as an associative tool that gives leaders real-time sightlines: patterns, dependencies, weak ties, early signals.

The first step isn’t “fixing” the org chart. It’s replacing false pictures with live clarity—then tuning roles, cadences, and incentives to match reality.

We'll do just that next Thursday.

Join me Thursday, Oct 23 @ 12:00–1:00pm ET for a free, working session: Leading in the Age of AI. You’ll leave with:

• A simple lens (inspired by Goldratt & Deming) to see where your organization’s real bottlenecks live — and why fixing people rarely fixes the problem.
• Three small “center + edge” experiments you can run in the next 30 days to close drift and improve flow.
• A fresh view of AI as a leadership instrument — one that helps you see the system without surveillance or blame.

Register Now

What if AI could help your ministry reach more people, deepen relationships, and free up time for what matters most?

That is what we will explore in our free upcoming virtual event, “AI for Churches: Empowering Ministry in the Digital Age.”

Join us for a session with leading voices in faith-based AI innovation. Don Barger, Director of Innovation and AI at IMB, and James Cuthbert from Biblica will share how churches can thoughtfully use Chipp to enhance their impact.

Register Now

Why AI for Ministry?

AI is not about replacing people or faith. It is about supporting the work you already do. Imagine having a digital assistant that can:

• Answer common questions from members or visitors, any time of day
• Translate sermons, devotionals, or announcements into multiple languages - Help organize events, manage resources, or track prayer requests
• Offer personalized support to members, from newcomers to long-time congregants

With the right tools, AI can help churches focus on what matters most: building authentic relationships, serving their communities, and sharing their message.

What You Will Learn at This Event

• How to build custom AI agents that reflect your church’s unique mission and values. No tech background needed.
• Real-world stories of churches already using AI to serve, connect, and grow.
• Best practices for keeping ministry personal and meaningful, even as you explore new technology.

We will also talk about how to protect sensitive information, ensure privacy, and use AI in a way that aligns with your church’s beliefs.

Meet Our Featured Speakers

Don Barger, Director of Innovation and AI, International Mission Board (IMB)

Don Barger brings over 28 years of experience in global ministry and technological innovation. As Director of Innovation and Artificial Intelligence at IMB, Don has led initiatives across Latin America, focusing on storytelling, orality, and building global partnerships. He holds a PhD in Missions, Church History, and Theology, and a certificate in AI from MIT Sloan. Don is also an adjunct professor, author, and bilingual leader dedicated to helping churches harness technology for good.

James Cuthbert, Biblica

James is the Global Digital Product Development Manager at Biblica, where he leads digital innovation to make Bible translations and resources more accessible worldwide. With a background in both technology and theology, and over 15 years of experience in digital product development and IT management, James brings valuable insight into how faith communities can use technology to serve and connect.

How Chipp.ai Supports Churches

Chipp is designed to make AI accessible, safe, and meaningful for faith communities.

Here is how it can help:

• Custom AI applications: Build tools that answer questions, share resources, or guide members, all tailored to your congregation’s needs.
• Privacy and security: Keep pastoral conversations and community data safe, with controls that fit your values.
• Member engagement: Use AI to check in with members, send reminders, or offer support, while keeping the personal touch.
• Resource optimization: Automate routine tasks so your team can focus on ministry, not paperwork.

Why Now?

The digital age brings new challenges and opportunities for churches. By learning how to use AI thoughtfully, you can:

• Reach people who might never walk through your doors
• Support your team and volunteers with smart tools
• Make your ministry more welcoming, inclusive, and effective

AI is a tool. How you use it is up to you. Let’s explore together how technology can serve your mission, not the other way around.

Event Details

• Date: October 21st, 2025
• Time: 11:00 AM Central Time
• Format: Online Virtual Event

**Register here.**

This means an independent third-party auditor has verified that our security controls aren't just well-designed—they work effectively over time to protect your data.

From day one, we've been committed to building an AI agent builder that provides additional privacy options. SOC 2 Type II certification is proof of that commitment.

What is SOC 2 Type II?

SOC 2 is the gold standard for SaaS security and data protection.

There are two types:

SOC 2 Type I verifies that security controls are properly designed at a specific point in time.

SOC 2 Type II goes further. It verifies that those controls operate effectively over an extended period of time with continuous monitoring. That's us!

The certification covers five trust principles:

• Security - Protection against unauthorized access
• Availability - Systems are available for operation and use
• Processing Integrity - System processing is complete, valid, accurate, timely, and authorized
• Confidentiality - Confidential information is protected
• Privacy - Personal information is collected, used, retained, disclosed, and disposed of properly

This isn't self-certification. An independent auditor examines our infrastructure, policies, and procedures, then monitors them continuously to ensure we meet strict standards. Thanks Advantage and Vanta for the help!

Why It Matters

SOC 2 Type II certification isn't just a badge. It changes what we can do for you.

Enterprise requirements are met. Many organizations require SOC 2 Type II before they'll sign a contract. This certification removes that barrier.

Continuous improvement is built in. We're not audited once and done. We maintain and improve our security controls year-round to stay certified.

Additional certifications follow. SOC 2 Type II is the foundation for HIPAA, FERPA, and other compliance frameworks. We're already working on these.

You get competitive advantage. When you use Chipp with your clients, you can confidently say your AI platform meets enterprise security standards.

Who Should Care?

Agencies and consultants building AI solutions for clients: You're trusting us with your professional reputation and your clients' data. SOC 2 Type II means that trust is validated by independent auditors, not just our promises.

Businesses sharing professional and personal information: Whether you're uploading company documents, client data, or personal files, you need to know they're protected. SOC 2 Type II proves they are.

Healthcare organizations subject to HIPAA: SOC 2 Type II is a prerequisite for HIPAA compliance. This certification means we're ready to support your healthcare AI needs.

Educational institutions managing student data under FERPA: Student privacy is non-negotiable. SOC 2 Type II demonstrates we have the controls in place to protect it.

Financial services firms with strict data protection mandates: Regulatory compliance starts with verified security controls. SOC 2 Type II checks that box.

Enterprise IT and security teams evaluating AI vendors: Your procurement process likely requires SOC 2 Type II. Now you can move forward with Chipp.

Chipp's Privacy-First Approach

SOC 2 Type II certification supports all three of Chipp's privacy tiers:

Standard - Your data is never used for training. No model provider can use what you share to improve their models.

Zero Data Retention (ZDR) - Conversations and files are immediately deleted from LLMs. Nothing is stored on the AI model providers servers. This is available on our Business Plan.

Private Cloud - Run Chipp on your own infrastructure with a private domain. Maintain complete data sovereignty. This is our Enterprise Add-On option.

SOC 2 Type II means these privacy controls are verified and monitored continuously.

Learn more about our privacy tiers on our plans page

What's Next?

Want to see the details? Visit our Trust Center for complete security documentation.

Need a copy of our SOC 2 report? Contact us and we'll provide it.

Ready to explore which privacy tier fits your needs? Check out our plans.

We built Chipp to be the AI platform you can trust with your most important data. SOC 2 Type II certification proves we're delivering on that promise.

Your data deserves enterprise-grade security. Now you have it.

*This post is brought to you by Maaria Tiensivu, Chipp Gold Partner and founder of **Purpose Driven AI**.*

What does it mean to build AI with purpose? In a recent conversation with IBM’s Íñigo Cavestany Villegasas, we explored the crucial differences between AI assistants and agents, the lessons learned from gaming, and the real-world responsibilities that come with building intelligent systems.

For those who want to dive deeper, you can watch the full conversation here: 👉 Watch the full YouTube video

Here are the key insights—and how you can put them into action today.

1. Know the Difference: AI Assistants vs. AI Agents

Insight: AI assistants help you complete tasks, but AI agents can act on your behalf, make decisions, and even learn from their environment. This distinction is more than technical—it’s about trust, autonomy, and responsibility.

Put it into action:

• Before building, ask: “Do I need an assistant or an agent?”
• For simple, repeatable tasks, assistants are ideal. For workflows that require adaptation or decision-making, agents are the future.
• With no-code tools like Chipp.ai, you can experiment with both—start with a simple assistant, then evolve it into an agent as your needs grow.

2. Small is Powerful: The Rise of Specialized AI

Insight: The future isn’t one giant AI that does everything. It’s a network of smaller, specialized models—each designed for a specific purpose.

Put it into action:

• Don’t try to build a “do-it-all” AI. Instead, focus on solving one problem really well.
• Use Chipp.ai’s modular approach to create multiple agents, each with a clear, narrow focus.
• Regularly review and refine your agents—specialization leads to better results and fewer surprises.

3. Learn from Gaming: Technology as a Force for Growth and Connection

Insight: Íñigo’s journey from competitive gaming to AI leadership revealed that, when used intentionally, technology isn’t just about efficiency or automation—it can be a powerful catalyst for personal growth and deeper human connection.

Put it into action:

• Approach AI and technology as tools to bring people together, not just to optimize processes.
• Design your AI projects to foster collaboration, learning, and shared experiences—just as gaming communities do.
• Use platforms like Chipp.ai to build agents that support teamwork, mentorship, or community engagement, amplifying the human side of innovation.

4. Ethics by Design: Ask the Hard Questions Early

Insight: Real-world AI mishaps often come from ignoring ethical questions until it’s too late. Responsible builders ask tough questions from the start.

Put it into action:

• Before launching, ask: “What could go wrong? Who could be harmed?” Use the answers as a guiding force to make your AI solutions better.
• Use Chipp.ai’s privacy and control features to safeguard user data and limit unintended consequences.
• Involve diverse voices in your design process—ethical AI is a team sport.

5. Human-AI Collaboration: The Future is Hybrid

Insight: The best results come when humans and AI work together, each doing what they do best.

Put it into action:

• Design your agents to augment, not replace, human expertise.
• Use Chipp.ai to embed your own knowledge and documents, creating agents that truly understand your context.
• Keep humans in the loop for critical decisions—AI is a partner, not a replacement.

Final Thought: Build with Purpose, Lead with Action

Building AI isn’t just about technology—it’s about intention, responsibility, and impact. Whether you’re a business leader, developer, or simply curious, the path forward is clear: start small, ask the right questions, and build with purpose.

Ready to put these insights into action? Try building your first assistant or agent with Chipp.ai—no code required.

Want to watch the full conversation? 👉 Building AI with Purpose: AI Assistants, Agents & Human Responsibility (YouTube)

We’re also gearing up for **three exciting events** that explore how AI transforms leadership, ministry, and business. Join us for AI for Churches, Leading in the Age of AI, and our big in-person event, Chipp Con: SC!

AI Highlights from Around the Web

AI is driving massive energy demand

According to Citi, AI computing demand could require an additional 55 GW of global power capacity by 2030, representing $1.4 trillion in AI-related infrastructure spending in the U.S. alone.

Check out the post.

🌶️ Bubbles create customer surplus. With AI, much of the spend goes to GPUs (basically computers). As we know, computers aren’t worth much a few years later. The actual durable surplus coming from the AI buildout will be energy as I argued here.

Jeff Bezos: AI training data centers could move to space

Amazon’s founder predicts that within 10–20 years, AI training clusters could be powered by 24/7 solar energy in space. It’s a wild vision that could transform Earth’s energy and industrial systems.

Watch the clip.

🌶️ As we look at the massive energy needs, people are looking to new options to capture energy. This blue ocean (blue atmosphere?) thinking could lead to massive leaps in quality of life and massive changes in how our society operates.

AI scribes reduce burnout among doctors

A new study found that doctors using AI note-taking tools experience a 25% drop in burnout and gain more time to focus on patient care. It’s a powerful reminder that AI’s best wins often come from small, focused use cases that remove tedious work.

Explore this tweet.

🌶️ I’ve seen the burnout first hand as my wife would chart late into the night. Many of the most impactful uses of AI are already possible and just need to be implemented.

Chipp Updates

Blog: Build Your AI Homebase Before It’s Too Late

OpenAI’s Demo Day made one thing clear: every business needs its own AI strategy. Scott’s latest blog explains why building an owned AI system is the key to protecting your data, maintaining control, and staying ahead of platform shifts.

**Read the full post.**

Upcoming Workshops

We’ve got two virtual sessions designed to help leaders and organizations use AI with confidence and purpose.

AI for Churches: Empowering Ministry in the Digital Age (October 21 | 11 AM CT)

Learn how faith-based organizations are creating AI tools that enhance connection, protect community data, and strengthen ministry impact.

**Register here.**

Leading in the Age of AI: Your Org Chart is Lying to You (October 23 | 11 AM CT)

Bob Gower shares how AI is changing the way work actually gets done and why it’s time to rethink how your organization is structured.

Register here.

Chipp Highlights and Events

Chipp Con SC — Building AI for Business Knowledge

We’re heading to Greenville, South Carolina on October 30 for a full-day conference at Flywheel Coworking.

At Chipp Con: SC, you’ll:

• Learn how to turn your company’s data into AI agents that understand your business
• Build hands-on AI solutions you can use right away
• Connect with other leaders building real AI systems, not just talking about them

This is your chance to experience Chipp Con live. We'll see you there!

**Register here.**

OpenAI is angling to be the next aggregator, the next Microsoft or Google, going for everything: the attention, the data, the customer relationship.

Brian Balfour summarizes it well. AI is a new platform, following the same pattern we've seen in previous transformations. They start open, get developers to build, solidify a moat. Then: "The walls go up. The taxes increase. The rules change. What was once free becomes paid. What was once permitted becomes forbidden."

When facing an aggregator, **businesses need to own, not rent. Control the content *and* the platform.**

As Balfour argues, companies that thrive see the pattern. They prepare for the inevitable shift from open to closed.

Owning your AI is the new email list or website. It's how you build a direct relationship with your customers that can't be taken away by algorithm changes or price hikes.

Smart businesses recognize the need to integrate AI in to their owned channels. They can then safely use the scale of aggregators for distribution. Creating an owned AI strategy is a CRITICAL activity for all businesses to be able to ride the tailwinds of AI without getting hit with the challenges of relying solely on aggregators.

The OpenAI Operating System

This week's Demo Day announced agent builders, e-commerce integration, and apps—all on ChatGPT. This follows the Sora video model launch and hundreds of billions in data center investments.

All of these capabilities live on OpenAI's platform. They control the algorithm (models) that surfaces results and the data on what people say and search for.

As Ben Thompson puts it: "OpenAI is making a play to be the Windows of AI."

He continues:

This is a push to make ChatGPT the operating system of the future. Apps won't be on your phone or in a browser; they'll be in ChatGPT, and if they aren't, they simply will not exist for ChatGPT users. That, by extension, means the burden of making these integrations work—and those conversions performant—will be on third party developers, not OpenAI. This is the power that comes from owning users, and OpenAI is flexing that power in a major way.

Signüll puts the risk in stark terms:

it’s not really an application play.. it’s a data play. & giving your data to openai is effectively deepening their moat, since every app built here trains their system to do what you do. users stay in chatgpt. your edge decays over time.in essence devs are feeding openai context it doesn’t yet have, which then increases openai’s moat.

in essence devs are feeding openai context it doesn’t yet have, which then increases openai’s moat. the more useful their plugin, the faster their own differentiation evaporates.

We've seen this play out with the internet and social media. Don't just rent. Own your AI. Build direct access to your customers and data. They're too valuable to only reach on someone else's platform.

The AI PESO Framework

Think of AI as the next media channel businesses must master, just like ads, social media, or websites.

AI is following the PESO pattern of previous media: Paid, Earned, Shared, Owned.

Paid AI doesn't exist yet, but it's coming. OpenAI just launched e-commerce capabilities. It's easy to imagine the Google playbook: first show full results, then charge businesses to rank higher or take a referral fee. OpenAI recently hired Shiva Rajaraman, former VP of Commerce at Meta and Instacart's ads architect. Paid AI is on the roadmap.

Earned AI is exploding. AEO (AI Engine Optimization) is how businesses try to get mentioned in AI results. Early tactics like gaming Reddit mentions already lost effectiveness, much like early SEO tactics that quickly fell by the wayside. Expect businesses to reshape how they publish content to match what LLMs want. As Ben Thompson's Aggregation Theory shows: companies with demand dictate terms to suppliers.

Shared AI launched at Demo Day. ChatGPT now supports apps, e-commerce, and agent building—all requiring OpenAI's platform and models. Like posting on Facebook or YouTube, creators control the content but not the platform. The algorithm can change. You can't do anything about it.

Worse: AI can summarize and describe your business however it wants. Unlike Google, which ranks your site but doesn't change what it says, AI rewrites your message entirely.

Shared AI increases distribution but commoditizes your content. It's like Amazon—more eyeballs, but your product sits next to competitors with ads on top.

Owned AI is the homebase. Just as businesses have a website and then share content on social, they need an AI experience they control while also distributing to tools like ChatGPT.

Owned AI means you control both content and platform. Tools like Chipp let businesses control how LLMs behave for their customers and website visitors. The AI is "grounded" in your data—results pulled from your content, not the entire internet.

This is powerful. Customers get support or research products. You provide buy links to *your* products, answers from *your* blog, training from *your* materials.

Owned AI is having a Shopify store versus sending customers to Amazon.

You also keep the data. Track popular products, common questions, conversion patterns. Use those insights to improve marketing, training, pricing. Instead of giving valuable data to a shared platform, owned AI gives it back to you.

Control extends to security and functionality. Choose zero data retention, HIPAA or FERPA compliance, enable or disable specific features. On a shared platform, no such choices exist.

Owned AI in Action

95% of AI Proofs of Concept fail in businesses.

Why? They don't own the content and the platform. They can't give AI full context or make it behave the way they need.

Northern Illinois University wants AI tutors. But they don't want to just give students answers. They need to watch for students struggling, getting things wrong, thinking about dropping out, or showing signs of depression. Generic ChatGPT can't do that. Owned AI can.

A VC firm needs to write investment memos. They must share private deal data, search past investments, check their mentor network for fit, identify conflicts. Generic AI can't access that data securely. Owned AI can.

Visser Farms has dozens of farmhands needing training. They put QR codes in combines linking to owned AI chats providing training and support for their specific farm and equipment. Then they use Chipp trained on specific grain elevators to share current prices and help make selling decisions in real-time. Generic AI doesn't know their equipment, their contracts, or their buyers. Owned AI does.

This is the power of owned AI. Controlling how AI behaves and what it accesses (platform) while using the results to improve performance (content).

Build Now or Rent Forever

The starting gun just fired for the AI platform race.

Businesses face a choice: build their owned AI homebase now, or rent forever on someone else's platform.

History is clear. Instagram was free reach until you had to buy ads to reach your own followers. Google was free traffic until you had to pay for placement. Amazon was free distribution until fees and ads ate your margins, saying nothing about having them copy your products.

OpenAI is following the same playbook. Open and generous today. Taxes and walls tomorrow.

Smart businesses are building their owned AI now while also using ChatGPT, Claude, and others as distribution channels—not as their only AI strategy.

The cost of renting goes up every day. The cost of owning goes down every day.

Your customers are too valuable to only reach on someone else's platform.

Build your owned AI. Then distribute everywhere.

Spoiler alert—we say no.

We also explore why AI investment is different from the dot-com era, see how tech workers are leading AI adoption, and discover why even a "bubble" might help us build the future faster.

Plus, **learn how to bring data from any source into your Chipp assistants**, **trigger emails automatically from conversations**, and **build multi-agent systems**.

Catch up on last week's **Vibecoding workshop** and **AI for Non-Profits session**, and join us in South Carolina for Chipp Con!

AI Highlights from Around the Web

AI's Unexpected Economic Role

Deutsche Bank warns that the AI bubble might be the only thing holding the US economy together. A surprising turn of events considering how much doubt surrounded AI's economic impact.

Explore this tweet.

🌶️ Massive spend on AI infrastructure, and data centers in particular, are huge economic drivers, but they are masking weakness in other areas of the economy. Expect tech to continue to drive growth.

The AI Slowdown That Wasn't

Ethan Mollick shares data showing that predictions of an "AI adoption downturn" were wrong. Businesses are finding AI useful, and adoption continues to grow. Check out the thread.

Explore this tweet.