Essays by Ry Walker
Essays on AI, startups, and software engineering by Ry Walker, founder of Tembo and Astronomer.
About this collection
This is a working library about building software companies while the way software gets made is changing. The essays treat AI agents as software systems rather than magic prompts: systems that need context, infrastructure, review, ownership, security, and operational discipline. They follow the problems that appear after a demo succeeds—when an agent must work inside a real codebase, coordinate with people and other agents, use credentials safely, survive changing requirements, and produce work a team can inspect and trust.
The agent chapters move from first principles into deployment, build-versus-buy choices, harnesses, memory, multi-agent architecture, workflow design, governance, and defense. They are written for founders, engineering leaders, and practitioners deciding what to build, what to purchase, and how to redesign the organization around much cheaper software creation. Individual essays are deliberately short; the chapter structure turns them into a longer argument that can be read in sequence or used as a reference.
The business chapters collect lessons from building products and companies over several technology cycles. They cover founder judgment, early product discovery, open-source strategy, developer productivity, go-to-market systems, fundraising, and the uncomfortable gap between an attractive prototype and a product customers can rely on. These are first-person essays, not neutral documentation. Dates, context, and links matter, and readers should distinguish an observation from a sourced research claim.
For evidence-oriented work, the separate research section publishes sourced product profiles and category comparisons across AI coding and agent infrastructure. Agents can request Markdown from any canonical page, discover published items through the versioned public API, and consult the OpenAPI schema for typed operations. When citing this site, link to the canonical essay or research page so a reader can evaluate the full argument and its sources.
A useful reading path starts with “Agents Are Software, Not Prompts,” then follows the deployment and review chapters before moving into context, memory, and coordination. Founders evaluating a new product category can begin with the build-versus-buy series and continue into the notes on procurement, trust, and the services work that often appears between a prototype and repeatable software. The essays disagree with one another in places because they were written as the market changed; newer observations refine older ones instead of silently replacing them. Publication and update dates are part of the record. The goal is not a frozen doctrine, but an inspectable trail of how practical beliefs about agents, engineering, and company building evolve under real constraints.
On Agents
Agents Are Software
- Kill the MCP, Ship the CLI
- The Declarative Atomic Agent
- Agents Are Software, Not Prompts
- Prototype on MCP, Productionize in Code
- Sessions Replace Tasks, Runs, and Threads
- The Three Phases of AI-Assisted Engineering
- The Agent Is the Primitive, Not the Automation
- Automating Knowledge Work Is Software Engineering
- Ship the Agent Specs as Code, Not as Database Rows
Demo to Deployment
- The Mirror Problem
- The Pilot Is the Product
- The Demo Is Not the Deployment
- Start With the Mirror, Not the Model
- Vibe Code Has No Production Strategy
- Start With the Pain, Not the Platform
- The Agent Lab Replaces the Agent Deploy
- Your Agents Will Find the Dirty Data First
- The Proof of Concept Ends When Trust Begins
- Internal AI Tools Have a Twelve-Month Shelf Life
- The Operationalization Gap: Where AI Demos Go to Die
- Agents in Production: GTM Mesh and the Death of the ERP
- The First Agent You Should Ship Is the Operational Discipline Layer
Build vs Buy
- The Procurement Trap
- Homegrown Platforms Decay
- Don't Build the Eleventh CLI
- The Agent Stack Build-vs-Buy Map
- Buy the Integration Until It Breaks
- The Agent Buyer Map: Who Builds, Who Buys
- What the Build-vs-Buy Data Actually Shows
- Your Real Competitor Is the Internal Build
- The Real Product Is What Replaces Homegrown
- The Gap Is Infrastructure, Not Intelligence
- Customization Is the Moat, Not Model Quality
- The In-House Tool Dies When Its Builder Leaves
- The Reversion to Internal Software Has Started
- The Mega-Agent Fantasy Is Already Falling Apart
- Help Them In-House It, Don't Sell Them Another SaaS
- Agent Build Versus Buy: Why Engineers Keep Building It Themselves
Harness & Factory
- The Framework Trap
- The Agent Harness Problem
- The Harness Layer Has No Moat
- Software Factories Run on Pre-Prod
- The Framework Cannot Be the Product
- Your Agent Instructions Are Rotting
- The Harness Matters as Much as the Model
- Build the Infrastructure, Not the Harness
- Where the Agent Runs Is a Product Decision
- The Harness Is the Product. The Prompt Is Cheap
- The Slowest Part of Your Agent Is the Git Clone
- Agents Are Software, and Software Needs a Factory
- A Real VM Is the Primitive for Cloud Coding Agents
- The Harness Is Commoditized. Everything Else Is Not
- Give an Agent a Real Computer and It Stops Being a Coding Tool
- Investing in the Wrong Part of the Harness Is the Real Mistake
Context & Memory
- The Report Is Coming Back
- The Organizational Context Gap
- Stop Re-Deriving the Same Facts
- Agent Memory Is the Defensible Layer
- Context Engineering Is the Hard Problem
- Context Is the Moat — Don't Give It Away
- The Commit History Outlives the Veterans
- Each Person Needs Their Own Agent Instance
- Tech Context Is Tractable. Org Context Is Not
- The Real Product Is the Graph, Not the Interface
- Why Sandboxes Beat Vector RAG for Code Generation
- The Codebase Is the Territory. The Agent Needs a Map
- Tool Sprawl Is the Hidden Tax on Every Agent You Run
- Facts Rot. Reports Supersede. Build Memory Accordingly
- The Submodule Problem Is the Whole Problem in Miniature
- Three Layers of Agent Context, and Most Agents Have Zero
- Agent Memory Is Unsolved. Workflow-Scoped Learning Is Not
- Organizational Context Is the Hardest Problem Nobody Has Solved
- Two Maintenance Curves: Infrastructure Decreases, Context Never Stops
Mesh & Architecture
- The Orchestration Bet
- The Mesh, Not the Monolith
- The Convergent Agent Stack
- The Mesh of Specialists Pattern
- The Agent Infra Maturity Gradient
- Most APIs Are Not Ready for Agents
- Background Agents Are the Underbuilt Layer
- Event-Driven Agents Change What Is Possible
- The Calendar Is a Legacy Orchestration Layer
- Determinism Is a Bandage for a Bad Agent Loop
- Triggered Workflows Generate Most of the Volume
- The Orchestrator Is Where Your Tokens Go to Die
- The Bot Is the Container. The Agents Are the Work
- Start Agent Work in the Channel, Not the Terminal
- The Bot Is the Interface. The Agents Are the Units
- The Atomic Agent Mesh: Architecture, Build-vs-Buy, and the Review Layer
Workflows & Roles
- Agent Leverage Needs an Owner
- Start With Workflows, Not Roles
- With AI, Everybody Is an Engineer
- The Primitives Are the Same Across Roles
- What Workflow-First Looks Like in Practice
- One Human Will Supervise Hundreds of Agents
- Agents Are About to Break Out of Engineering
- The Operator Should Own the Agent, Not the Developer
- The Grayscale Between Engineering and Everywhere Else
- The Agent Owner Is a New Job, and It Is Not Engineering
- The Single Pane of Glass Is a Custom App, Not a Chat Window
Review & Trust
- Human Review Is Not a Limitation
- Code Review Becomes the Bottleneck
- The Algorithm Should Be Inspectable
- Review Needs a Computer, Not a Diff
- Generation Is Solved. Merging Is Not
- Review the Session, Not Just the Diff
- Inspectable Logic, Not Black Box Magic
- Controllability Beats Magic Every Time
- Review Is Not a Screen. It Is a Primitive
- Agents Start Broken and That Is the Point
- Taste Does Not Scale With Token Throughput
- Your Agent Pipeline Is Missing the Back Edge
- Non-Determinism Demands Human Correction Loops
- Merging Code Nobody Understands Is the Real Risk
- No Human Should See the PR Until It Has Been Beat Up
- The Agent Made a New Type Instead of Finding the Real One
- Review Is Not a Feature. It Is the Interface to Agent Work
- Spend Two Tokens Defending Code for Every One You Spend Writing It
- Controllability Is Not Optional. Enterprise Teams Do Not Want Magic
Coordination & Governance
- You Need a Directory of Agents
- Skills Are Software, Not Markdown
- The IKEA Effect Is Real for Agent Tooling
- The Coordination Crisis AI Tooling Created
- When Building Is Cheap, Coordination Breaks
- Users Should Iterate on Agents, Not Developers
- Agents Give the Signal Humans Are Too Polite to Send
- The Individual Contributor Picks the Model, and That Is the Cost Problem
Defense & Security
AI Coding Landscape
- The Road Ahead for AI Coding
- The Multi-Agent Platform Play
- From Code Writer to Code Judge
- The AI Coding Middleware Moment
- Democratizing Software Engineering
- Beyond the Coast-to-Midwest AI Gap
- The Cowboy Developer Era Is Ending
- The Three Tiers of AI Coding Adoption
- The Chaos in Coding Agents Is Our Friend
- Synchronous Cloud Development Is the Next Wave
- The IDE Is Going Away, and the Cloud Is Where Agents Run
- Cloud Dev Environments Are the Unlock for Parallel Agent Work
- Every CTO Is Asking How to Move Engineering Work to the Cloud
On General Business
Founder Notes
- Podcasts I Love
- Because I Had To
- Always Too Early, Never Wrong
- What I Learned Shutting Down OSSRank
- Give the Young Hire Four Jobs in Two Years
- The Underrated Power of a Positive Attitude
- Every Obvious AI Idea Gets Commoditized in Weeks
- The Weekly Progress Email Is an Artifact, Not Bureaucracy
- Remote Teams Run on Written Decisions, Not Hallway Conversations
Decision-Making & Intuition
Tembo & the AI Era
- The Tembo Manifesto
- AI Code Is Not Slop
- Why "Good Enough" Code Wins
- Personal AI Agents: The Complete Landscape
- Rise of the Agents: An AI Coding Ecosystem Map
- AI-First Software Development: Redefining How We Build Software
- I Asked 399 Developers for Their One Wish. Here's What They Said
- Measuring Developer Performance (And Why AI Might Make It Worse)
- Claude Code Just Got a Serious Upgrade, and I Can't Stop Using It
- The Future of AI Coding: Beyond Tools to True Autonomous Development
Engineering & Dev Performance
- The AI Coding Tool Wrinkle
- The GTM vs. R&D Measurement Gap
- The Gaming Problem Never Goes Away
- The 4X Mandate Without a Measuring Stick
- What Actually Helps Developer Performance
- You Cannot Measure Progress on Work You Never Defined
- Code Became Ephemeral, and Quality Became Blast Radius
- Top Performer Analysis: The Real Opportunity in AI Tool Telemetry
Open Source
Product & Growth
GTM & Platforms
- Think Small to Win Big
- Follow No Goose Absolutely
- The Design Partner Discipline
- Amplify the Tools They Already Trust
- Hourly Billing Cannot Survive Agents
- Self-Hosted Is Where the Real Pull Is
- Price for Adoption First, Profit Later
- Three Audiences, Three Agent Strategies
- Developers Want Raw Access, Not a Wrapper
- The Forward-Deployed Engineer Is the Wedge
- Catch the Buyers Before They Become Builders
- The Zero-Stickiness Problem at the Tool Layer
- The Three Services That Sell an Agent Platform
- Flexibility Is Not Optional for Agent Platforms
- From Agent to Platform: Why the GTM Is Services-Shaped
- GTM Mesh: Closing the Gap Between Ad Click and Revenue
- Wrap the Product in Services Until the Buyer Catches Up
- The Forward-Deployed Model Is the Only One That Actually Works
- The Arena of Arenas: Why There Is No Winner-Take-All in Agents
- Services Should Prepare Customers for Your Product, Not Compete With It
Markets & Strategy
- Provocatypes Over Roadmaps
- The Token Reckoning Is Coming
- The Fifth Inning and the First
- Pluck a Feather From Each Goose
- The Long Game in Agent Companies
- Everything Was an AWS Wrapper Too
- The Agent as ERP Is Not a Metaphor
- Running Out of Tokens Is a Buy Signal
- Crowded Starting Line, Empty Finish Line
- The Human Is No Longer the Integration Layer
- When Building Is Cheap, GTM Is the Only Edge
- Win at One Thing Before You Become a Platform
- The Unit of AI Consumption Is the Organization
- You Are Underspending on Tokens, Not Overspending
- The ERP Is Dead. The Agent Is Your Operating System Now
- Own the Compute Layer or Pay Someone Else's Margin Forever