Building Smarter Dev Environments for Humans and AI: The New Era of Software Productivity
What actually breaks AI agents in real teams, and how to fix it? In this Commit & Push episode, host Damien Filiatrault sits down with Rob Whiteley, CEO of Coder, to unpack a hard-earned lesson from the front lines of agentic development: most agents don’t fail because the models are weak, they fail because they’re dropped into environments with no context, no tools, and no guardrails.
Listen to the episode:
From Developer Environments to Agent Infrastructure
Coder started with a simple mission: remove friction from developer setup. Centralized cloud workspaces replace brittle local environments, making it easy for teams to provision compute, tools, credentials, and policies at scale.
What changed is who those environments are for.
As Rob explains, the same infrastructure designed for human developers turns out to be almost perfectly suited for AI agents—especially ones that run autonomously, touch real code, and operate inside enterprise constraints. The difference is lifespan: a human workspace lives for days or weeks; an agent’s workspace might exist for minutes. That ephemerality makes automation, reproducibility, and context non-negotiable.
Why Code Completion Isn’t the End Game
Autocompleting a line of code was the on-ramp. The destination is agents that can:
- Explore and understand a full codebase
- Propose tests and refactors
- Stub APIs and run full test suites
- Migrate entire systems from one language to another
The shift happened when tools like Cursor and Claude Code embedded AI directly into the developer workflow. Instead of “hit tab,” developers began offloading entire chunks of low-value work while staying in flow.
The result: developers stopped asking “Can AI help me type faster?” and started asking “Can it own this task?”
Agents Without Tools Are Just Blind Interns
One of the most useful metaphors in the episode is Rob’s comparison between agents and interns.
Dropping an agent into a repo without context or tools is like parachuting an intern into a company blindfolded and saying “get to work.” It’s no surprise when the outcome is poor.
This is where MCP (Model Context Protocol) enters the picture. MCP is essentially a way to give agents a tool belt—access to GitHub, browsers, internal services, and other capabilities they don’t have out of the box.
Coder’s key insight: because environments are provisioned as code (Terraform), an agent can read its own setup on boot. It immediately knows where it is, what it can access, and what tools are available. That context alone dramatically improves performance.
The takeaway: agents need infrastructure and context before they need more prompts.
Trust, Cost, and Long-Running Autonomy
Letting an agent run for hours—or even a full workday—sounds futuristic, but Rob shares real examples:
- Refactoring large codebases end-to-end
- Converting systems from one language to another
- Severing frontends from backends to create interactive demos
These workloads are possible today, but they’re not free. Long-running reasoning models can cost real money, which forces teams to choose between tight supervision and “YOLO mode.”
That tradeoff reveals a deeper truth: autonomy only makes sense when you trust the setup. If the agent has the right tools, permissions, and constraints, letting it run is productive. Without that, you’re just burning tokens.
The Adoption Curve Nobody Talks About
Rob observes a surprising pattern across teams:
- Junior engineers adopt agents quickly—they help them ramp up.
- Very senior engineers adopt agents quickly—they’re great at breaking work into discrete tasks and orchestrating multiple agents in parallel.
- Mid-level engineers often see diminishing returns—they trust the agent just enough to try it, but not enough to stop double-checking everything.
This “bathtub curve” isn’t about skill—it’s about mindset and workflow maturity. Over time, as best practices solidify and tooling improves, that curve is likely to flatten.
But the message is clear: agents reward people who think in systems, not just code.
Prompting Reality: System vs User Instructions
A particularly practical part of the conversation digs into how agents are actually controlled.
System-level prompts (set by model creators) define core behavior—like Claude’s habit of creating a to-do list and reporting progress. User-level prompts add instructions on top.
The catch: if your user instructions conflict with the system prompt, performance drops sharply. The model isn’t “deciding to be worse”—it’s confused.
Coder has spent real time reverse-engineering these interactions, packaging safe defaults for customers who want them, while letting advanced teams take full control. The lesson is simple but costly to learn the hard way: more prompting is not always better.
Security, Privileges, and Shared Environments
Running agents locally inherits all the privileges of the human. That’s a problem.
One advantage of centralized environments is the ability to give humans and agents different permission levels inside the same workspace. A developer might have full Git access, while the agent is restricted to a narrow set of commands.
That separation prevents the classic horror stories, like an agent deleting the wrong database, without blocking experimentation.
English Is the New Programming Language (With a Catch)
Damien and Rob zoom out to the bigger picture: programming has steadily abstracted upward, from punch cards to assembly to high-level languages. Agents push that abstraction to natural language.
English may be the interface, but not casual conversation.
For complex work, the future looks less like chatting and more like writing clear specs, reviewing plans, and approving execution. Voice and chat are great for small tasks; structured thinking still matters for big ones.
Ironically, non-developers often get better results because they over-explain. Experienced engineers tend to under-specify, assuming shared context that the agent doesn’t actually have.
AI as Interns, Not Replacements
Rob’s closing advice is blunt: if your organization doesn’t believe in training interns, agentic AI will feel like a burden.
Agents improve with investment. Teams that treat them as a talent pipeline (coaching, correcting, refining) see compounding returns. Teams looking for instant replacement will be disappointed.
Developers aren’t disappearing. But the role is changing. The most valuable people going forward won’t just write code, they’ll break problems down, communicate intent clearly, and orchestrate humans and machines together.
Bottom line: AI agents are already capable of real work. The differentiator isn’t the model, it’s the environment you drop them into.