The Amp Way
We Push to Main
We release many, many times a day. With agents, a lot of the old calculations of how you should develop software have changed. Time to fix bugs has gone down dramatically, time to diagnose issues too, the amount of stuff you can ship has gone up. We're all dogfooding the product.
We Don't Have Mandatory PR Reviews
Our core product team pushes to main. Why? In the age of agents and very smart models, we can all run many rounds of reviews. It's no longer necessary to open PRs and get reviews to catch bugs or little mistakes. Agents can do that, no need for humans; and even if some agents are dumber than some humans still: they don't get as tired, they don't get impatient, we can run them in a loop. We share threads and orbs and portals for others to review. We ask for feedback and link others. We have the agent send messages to other humans and ask them for input.
We Don't Use Our Local Dev Environment Anymore
We now have orbs and we found that agents can do so much now: from developing a feature, to pushing to main, to watching its rollout, to giving users a feature flag, to checking production logs, to starting new orbs to fix bugs that pop up. We build one-off tools in orbs (see ampcode.com/docs/using-amp) to iterate faster if we do need to be hands on. But we found ourselves simply not using our local dev env anymore. And with orbs, we all share the same standardized env. If someone on the team makes it better, it's better for everyone.
Feedback Loops for the Agents Above Everything Else
If the agent can't check its own work and test that something it built works, end to end, it's flying blind. If you don't give it the tools so it can exercise features completely in its dev env and check on them in production, you're tying one agentic arm behind its agentic back.
The Agent Works Every Step, Not Just the Coding Step
You don't get a big productivity gain by putting the agent in a box labeled "write code" and keeping every other step for humans. We use agents across the whole loop: reading the bug report, writing the code, pushing, watching CI, waiting for the deploy, checking production, finding the users who were affected, emailing them, giving them credits. A thread ends when the change has landed and we know it works, not when the code is written. That's where the leverage is. Not in a faster coding step, but in taking the humans out of the handoffs between steps.
We Don't Wait for Our Agents
Our agents wait on us, not the other way around. We use Orbs heavily: we start threads, they do their thing, if they're done they don't block any other work. They don't take up resources, or cost anything. We get back to them once we're done.
Agents Are Allowed to Do Ops
We use OIDC and read-only permissions to allow agents access to production logs and metrics. We let agents help us administer clusters and investigate failing containers. It writes Terraform files for us. Agents in ops are a game-changer.
We Don't Keep a Backlog
Why keep a list of bugs when you can start an agent on each one? When a bug report comes in, we start an orb for it right away. The agent reproduces the bug, fixes it, and proves the fix works. Later, when we have a minute, we look at what it did. Most of the time it's right and we push it. Sometimes it's wrong and we've still learned something about the bug. Either way, the bug got attention while the person who reported it still cared, and they hear back in minutes, not in a quarter.
We're Constantly Killing Features
When it’s so cheap and fast to add new things, it’s easy to fall into the trap of adding every little thing that pops into your head. Complexity compounds though and we need to be mindful of it. Kill what you aren’t using, kill what "might be nice some day", kill what makes developing other things in the future harder.
Every New Model Is a Reset
New models arrive every few months and each one is a reason to ask what we can stop doing. Scaffolding we built around the last model can probably go. Tasks we didn't dare hand off can now be handed off. We can aim higher. So with every release we look at our own work and ask: what can I not do anymore, because the agent can do it now?
We Write for Humans Ourselves
Prose that another person will read, we write by hand: Slack messages, emails to users, announcements, this page. We're allergic to LLM-written prose. Agents can research, prepare, and draft, but if a human is going to read it, a human writes it, or at least finishes it. It's a matter of taste, and it's polite.
“We Thought It Would Be Fun”
This is the opposite force. With agents we can now build delightful little experiences — animated orbs that explode when you click them often enough, animated buttons that shoot laser beams, an in-app podcast player, a trumpeter that announces new features and plays a sound on click — that would’ve previously cost a person days and just weren’t worth it. Now they are. Time to build delightful things.