The Modern Software Engineer
Mihail Eric, Head of AI at Monaco and Stanford Lecturer, discusses the fundamental shift in software engineering due to AI. He explores how the developer's role is evolving from a line-by-line coder to a systems architect and agent director, emphasizing the growing importance of upfront planning, robust validation, and clear articulation to effectively manage AI-driven workflows.
The role of the software engineer is undergoing a fundamental transformation, shifting from a focus on writing code to designing systems and directing AI agents. This new paradigm requires a different set of skills, emphasizing architecture, planning, and validation over line-by-line implementation.
The Evolving Developer: From Coder to Architect
The modern software engineer’s primary responsibility is moving up the stack. Instead of being “finger on keyboard, write this function,” the job is increasingly about designing, architecting, and understanding the “why” behind a feature. Key aspects of this evolution include:
- Bridging the Knowledge Gap: AI agents can serve as a powerful tool for junior engineers. They can generate code and, more importantly, summarize implementation details and learnings, helping to close the experience gap with senior developers who traditionally filled this mentorship role through pair programming and code reviews.
- The Agentic Dilemma: Developers often face situations where an agent produces code that works but is implemented in a way they wouldn’t have chosen. The recommended approach is to maintain strong architectural control over core infrastructure while embracing the agent’s “creativity” in less critical areas or with unfamiliar frameworks (e.g., Next.js, Vue). This can be a valuable learning opportunity, treating the agent’s output as a valid prior when you don’t have a strong opinion.
Best Practices for Agentic Workflows
To effectively leverage AI agents, especially in autonomous or long-running tasks, the human’s role shifts to that of a system validator and manager.
- The Primacy of Validation: The most crucial piece of the puzzle is the validation and testing harness. The developer’s primary job is to create robust checks to ensure that an agent’s work is correct and doesn’t break existing functionality. This involves thoughtfully defining edge cases and assertions. The agent can write the boilerplate test code, but the human must design the logic of what needs to be validated.
- The Frontier of Verifiability: There are current limits to what can be easily and automatically validated, such as infrastructure changes, DNS routing, or interactions requiring API key retrieval. These areas represent the frontier where human-in-the-loop is still essential and where fully autonomous, long-running agents hit their limits.
- Strategic Parallelization: While running numerous agents in parallel is often romanticized on social media, a more practical approach is to focus on one or two “meaty” tasks that require significant human oversight and a separate list of smaller, well-defined tasks (e.g., simple refactors, adding a configuration) that can be kicked off to agents during downtime. This requires more deliberate upfront planning.
Team Dynamics and Economics in an AI-First World
The integration of AI is reshaping team structures, collaboration, and the economic models of software development.
- Disseminating Knowledge: As with the rise of CI/CD, teams need to establish centralized best practices for using AI. This can be managed by internal developer success teams and documented in shared resources like an
agents.mdfile. The goal is to elevate the entire team’s proficiency to the level of its top users. - Converging Roles: The lines between engineering, product, and design are blurring. Product managers can now submit PRs for small changes, and even go-to-market teams can query the codebase via an agent to get the most up-to-date information on features. This cross-functional capability leads to smaller, more efficient teams with a higher concentration of context, which increases development speed.
- The Cost of AI: The current token-based pricing model is a significant tension point, as it can be inefficient and costly. There is a potential future where pricing shifts to an outcome-based model (i.e., paying for task completion), but this is challenging for companies that don’t own the underlying models. The advancement of open-source models is seen as a key enabler for this potential shift.
The New Essential Skills for Software Engineers
In this new era, technical skills are augmented by a renewed emphasis on communication and strategic thinking.
- Planning and Delegation: As developers begin directing multiple agents, they are implicitly taking on management responsibilities much earlier in their careers. The ability to plan a project, break it down into delegable tasks, and oversee the work of agents becomes a crucial skill.
- Articulation as a Superpower: The ability to clearly and precisely articulate a task, provide necessary context, and define success criteria is paramount. Poor communication leads to wasted time and incorrect results, whether dealing with humans or agents. Clear articulation is a forcing function for better thinking and is becoming one of the most valuable skills for an engineer.