Future-Proofing Software Development: LLMs Reshape Roles, Teams, and Cognitive Load

The rise of Large Language Models (LLMs) is sending ripples throughout the software development world, forcing a critical examination of existing roles and workflows. Recent discussions at the Thoughtworks Future of Software Development Retreat paint a picture of both excitement and uncertainty as developers grapple with the implications of AI-powered coding assistance.

One key theme emerging from the retreat is the evolving role of senior developers. Rather than fearing obsolescence, senior engineers are increasingly viewed as architects and orchestrators, leveraging LLMs to handle lower-level coding tasks and focusing on higher-level architectural challenges. Interestingly, some developers who had stepped away from active coding are finding LLMs empower them to re-engage with code, managing LLM agents in a manner analogous to managing junior developers. Skepticism towards LLMs among senior developers appears to diminish significantly with hands-on experience, as recent advancements demonstrate capabilities that quickly surpass outdated perceptions.

The fate of junior and mid-level developers is also under scrutiny. While there are concerns that LLMs could displace junior roles, the consensus at the retreat was more optimistic. Junior developers, often more open to new technologies and familiar with LLMs, are seen as vital. The most significant challenge appears to lie with mid-level developers, who lack both pre-LLM experience and the architectural oversight to effectively harness the power of these tools. LLMs can potentially serve as always-available mentors, guiding junior developers toward improved programming practices. However, a degree of skepticism, akin to what one applies to human mentors, remains essential.

A critical aspect often overlooked is the growing issue of 'cognitive debt'. Unlike technical debt which refers to cruft in code, cognitive debt arises from a fragmented understanding of a system's design and purpose. As teams rush to deploy features, the shared understanding of the underlying architecture can erode, leading to a point where even simple changes become problematic. This 'ignorance,' as it was called, can hinder both human developers and AI agents alike. Just as managing technical debt requires proactive refactoring, addressing cognitive debt demands deliberate investments in knowledge sharing and documentation.

Interestingly, efforts to improve the Developer Experience (DevEx) are also proving beneficial for LLMs. Streamlined tooling, clear documentation, and well-defined development environments enable LLMs to generate more accurate and efficient code. This recognition is driving management to invest in these areas, although the motivation seems skewed towards optimizing for AI agents rather than human developers, sparking some concern about prioritizing robots over people.

The future of Integrated Development Environments (IDEs) is also being re-imagined. IDEs need to incorporate LLMs not just for code generation, but also to guide developers in effectively utilizing both AI-powered and deterministic tools. An IDE could orchestrate a mix of LLM-driven code generation and traditional refactoring tools, automating complex tasks like renaming entities across an entire codebase. This highlights a shift toward supervisory programming, where developers manage and guide AI agents rather than directly writing code.

The implications for team size and structure are also being considered. While some fear that LLMs will shrink teams, there's a counter-argument that teams will remain the same size but achieve significantly more. The concept of 'pair programming' may also evolve, with two human developers potentially collaborating to manage multiple LLM agents, combining the benefits of human collaboration with the code-generating power of AI. However, this potential increase in productivity could lead to burnout and decreased work quality. Studies are showing developers are taking on more work and working more hours, leading to cognitive fatigue. As Camille Fournier points out, everyone is becoming a manager in a way, forced to juggle numerous tasks at once. Supervisory programming is becoming the new normal and it remains to be seen if programmers can effectively manage context switching and maintain a high level of work quality.