Ryan Carson - Compound Product: Autonomous Product Development

Key Insights

• The founder is now the bottleneck: We’re all stressed because we’re still manually deciding what to build instead of letting agents loop autonomously 24/7. “You are now the bottleneck, right? So you need to be thinking of the ideas to improve your app and then proactively going and building those things.” [00:04:38]

• Bash scripts are the new infrastructure: Context limits disappear when you use bash to orchestrate agents instead of trying to do everything in one session. “There’s a lot of value to bash scripts and bash loops because you don’t run into context limits.” [00:07:07]

• Humans are just loops: Organizations are already autonomous systems, we just haven’t automated them yet. “All we as humans are, are loops. Like you wake up, you read your email, you look at your data, you decide what to do, you implement it, and you go to sleep.” [00:23:590]

• Ship bigger features: If you’re not feeling the need for Ralph-style loops, you’re probably not shipping ambitious enough features. When asked why use loops: “I think you’re not shipping big enough features, Kieran. Sorry.” [00:23:10]

• AGI made life stressful, not calm: “I thought AGI, which it feels like we basically are sort of here. I thought it would make my life calm, but it’s made it very stressful.” [00:16:15]

Summary

Ryan Carson, founder of Untangle (an AI divorce assistance platform), recently stepped back from being a builder in residence at AMP to focus full-time on his startup. In this session, he demonstrates “compound product” - an evolution of Kieran’s compound engineering and Jeff Hunt’s Ralph loop that creates fully autonomous product development cycles.

The core insight: instead of manually reviewing analytics, deciding what to build, and then implementing it, you can create a cron-based system where agents automatically analyze product data, identify problems, write PRDs, and implement fixes overnight. You wake up to a PR rather than a to-do list. This isn’t rocket science - it’s just basic product iteration (get data → analyze → decide → implement → fix) but fully automated and running continuously.

Main Topics

The Compound Product Loop Architecture

Ryan walks through a mermaid diagram showing the full autonomous loop:

Phase 0 - Automated Reporting: - Cron job runs nightly at midnight - Pulls data from database (Postgres in Ryan’s case) - Sends to Opus 4.5 with prompt: “based off of this data, what is the one thing we should do?” [00:05:37] - Generates markdown report with insights about acquisition, retention, etc. - Email notification sent

Phase 1 - Analysis: - Bash script reads the most recent report - Analyzes the problem identified - Creates analysis.json with priority, rationale, and suggested fixes - “You have a problem with your free trial page signup flow. Something is wrong. You’re not getting signups.” [00:12:50]

Phase 2 - Planning: - Creates feature branch - Loads PRD skill to write detailed product requirements - Generates atomic user stories with clear acceptance criteria - Creates prd.json with structured tasks

Phase 3 - Task Refinement: - Loads tasks skill to review all user stories - Ensures each task is truly atomic and has testable acceptance criteria - Checks that browser testing requirements use agent-browser - Warns if agent-browser isn’t installed

Phase 4 - The Ralph Loop: - Picks task from JSON - Implements task - Runs quality checks - If fails: fixes and retries - If passes: commits and updates JSON - Updates progress.txt (short-term memory) and agents.md (medium-term memory) - Repeats until all tasks complete

Phase 5 - PR Creation: - Bash script pushes branch - PR ready for review

“Why don’t I just automatically do whatever it’s suggesting? This is kind of dumb that like it’s waiting for me to say, yeah, go do it.” [00:06:36]

AMP vs Other Tools

When asked to explain AMP: - Direct competitor to Claude Code - “Both amazing products” - Chose AMP because “the product is just so good. There’s so much work that goes into the harness around the model” [00:02:53] - Uses the 2E version - Offers free tokens paid for by ads - “I get free tokens and it’s sustainable and we’re not going to take that away from you” [00:03:31]

The Power of Bash and Non-Interactive Agents

Key technical insight on why bash matters:

“You can call an agent from the command line, right? So you can invoke amp. You can invoke cloud code from the command line. And in amp, you basically say amp dash X, and then you give it a prompt and then it fires up an instance of amp, non-interactively.” [00:08:24]

Benefits: - No context limits - Can spawn thousands of instances - Each instance works independently - “I think it’s hilarious that we’re all using bash now” [00:08:59]

The Three Tiers of Agent Memory

Ryan explains memory management in the Ralph loop:

1. Long-term memory: “Trained into the model” - the base knowledge
2. Medium-term memory: agents.md - “things obviously that every eng needs to know when they’re working in your repo” [00:21:01]
3. Short-term memory: progress.txt - “the gotchas that you’re running into that you don’t want the next loop to have to relearn, but you don’t really want to remember it forever” [00:21:23]

At the start of each loop, checks progress.txt for learnings. If something needs to be remembered longer-term, adds it to agents.md. This is the “genius” of compound engineering.

Agent Browser Integration

Critical detail about acceptance criteria:

“If your acceptance criteria includes browser testing, then you need to be using something like agent browser.” [00:18:28]

The compound product script: - Checks if agent-browser is installed - Warns if not present - Tasks skill specifically uses agent-browser for browser testing acceptance criteria - “If you’re not using agent browser, what are you doing? It’s like amazing. It’s the best.” [00:18:33]

Why This Matters Now

The philosophical shift:

“The speed that we’re all going to get out iterated here is unprecedented. And I think if you’re a founder or a builder, you should be really nervous all the time now.” [00:16:02]

“I have massive FOMO all the time now because I don’t have three instances of AMP running 24/7.” [00:15:57]

On why this is possible now: “It’s Opus 4 or 5. I mean, it’s like as simple as that. The model is good enough now to really complete any well-defined user story with clear acceptance criteria, as long as it’s atomic Opus 4 or 5 can do it.” [00:09:34]

Open Source and Tool Agnostic

The repo is fully open source and designed to work across tools: - Works with Claude Code, Codex, Cursor, AMP - Supports Anthropic key, AI gateway key, or Open Router key - Built on Kieran’s compound engineering + Jeff Hunt’s Ralph Loop - Available on GitHub (link shared during session)

“This is not rocket science people. I think many of us are arriving at the similar place where we need to be looping to autonomously improve our products, our engineering, our life.” [00:01:22]

The Missing Piece: Founder Brain State

When Kieran asks about incorporating founder thinking beyond just user data:

“This is a hole, I think, in the system. I probably need to be going in and journaling more about my thoughts as the GM.” [00:24:31]

Kieran’s solution: Limitless app with Mac mini recording everything - “Everything is in the Mac mini” [00:26:01] - Runs cron jobs on recordings - Extracts Quora-related context - Feeds into similar flow

Ryan: “You should do a PR on this thing…add a pre step where you’re like, I actually need to make sure that all of this has the context of me as the founder.” [00:26:21]

Untangle: The Backstory

Brief context on Ryan’s startup: - AI divorce agent - Built because “my sisters got divorced and it was heartbreaking to see them go through what they went through” [00:14:00] - “I hope nobody ever needs my product” [00:13:56] - Conversion rates look bad because “divorce products take a long time for people to purchase them” [00:14:01]

Actionable Details

Installation

From the repo, run the provided command to install compound product into your repo. AMP (or your agent) will: - Install bash scripts - Set up folder structure for reports, tasks, PRDs - Configure skills (PRD, tasks, loop)

Running It

# Dry run to test
[run command from repo]

# Finds most recent report
# Analyzes it
# Creates analysis.json
# Shows rationale without executing

Required Setup

1. Data Pipeline: Create cron job that pulls key metrics from your database (Postgres, etc.) and sends to Opus 4.5 for nightly report
2. Agent Browser: Install agent-browser for browser testing acceptance criteria
3. Model: Use Opus 4.5 (or equivalent quality model)
4. Memory Files: Set up agents.md, progress.txt, task folders

Key Files Structure

• /reports/ - Nightly markdown reports from analytics
• analysis.json - Parsed problems and suggested fixes
• prd.json - Product requirements with atomic tasks
• progress.txt - Short-term learnings (per-feature)
• agents.md - Medium-term knowledge (repo-wide)

Skills Included

1. PRD Skill: Takes analysis, writes detailed PRD with atomic user stories and acceptance criteria
2. Tasks Skill: Reviews PRD, ensures atomicity, adds agent-browser requirements where needed
3. Loop: Standard Ralph implementation - picks task, implements, checks, commits, updates JSON

Tips from Ryan

• “Don’t overcomplicate it” [00:10:36]
• For data: “If you don’t know what data to pull, talk to your agent about it and say, Given our product does X, Y, Z, like what’s the two numbers we should pay attention to” [00:11:00]
• “This is why you hire people. This is why we used to hire VP of marketing because they would look at data every day and they would give you actionable insights. Well, it turns out for 15 cents, you can do that every day.” [00:11:12]
• Think about loops: “You should have a daily report…and that thing should be pulling information from your app, whatever is important to you. And it should be essentially acting as a VP of product or a VP of engineering or a VP of sales.” [00:10:05]

What Makes a Good Task

From the tasks skill requirements: - Truly atomic (one clear thing) - Clear acceptance criteria that an agent can autonomously verify - If includes browser testing → must use agent-browser - Should be completable by Opus 4.5 without human intervention

Tool Recommendations

• AMP: amp -x "prompt" for non-interactive agent invocation
• Agent Browser: Essential for browser testing acceptance criteria
• Opus 4.5: Capable enough to complete well-defined atomic tasks
• Bash: For orchestration and avoiding context limits
• Limitless + Mac mini: For capturing founder brain state (Kieran’s setup)

Quotes Worth Saving

“You are now the bottleneck, right? So you need to be thinking of the ideas to improve your app and then proactively going and building those things.” [00:04:38]

“I was reading this report the other day and I’m like, why, why don’t I just automatically do whatever it’s suggesting? This is kind of dumb that like it’s waiting for me to say, yeah, go do it.” [00:06:36]

“There’s a lot of value to bash scripts and bash loops because you don’t run into context limits.” [00:07:07]

“It’s Opus 4 or 5. I mean, it’s like as simple as that. The model is good enough now to really complete any well-defined user story with clear acceptance criteria, as long as it’s atomic Opus 4 or 5 can do it.” [00:09:34]

“I have massive FOMO all the time now because I don’t have three instances of AMP running 24/7. Like, and it’s real, like the speed that we’re all going to get out iterated here is unprecedented.” [00:15:57]

“I thought AGI, which it feels like we basically are sort of here. I thought it would make my life calm, but it’s made it very stressful.” [00:16:15]

“I shouldn’t have to wake up and decide what got built overnight. Like I should wake up to a PR. And then eventually I should wake up to a shipped PR because I have another loop deciding if it should be shipped.” [00:17:34]

“All we as humans are, are loops. Like you wake up, you read your email, you look at your data, you decide what to do, you implement it, and you go to sleep, right? This is what our armies of agents should be doing.” [00:23:590]

“I think you’re not shipping big enough features, Kieran. Sorry.” [00:23:10]

“This is why you hire people. This is why we used to hire VP of marketing because they would look at data every day and they would give you actionable insights. Well, it turns out for 15 cents, you can do that every day.” [00:11:12]