Summaries > AI > Mit > MIT Professor: Why Coding Agents Won’t Replace Software Engineers | Armando Solar...

Mit Professor: Why Coding Agents Won’t Replace Software Engineers | Armando Solar Lezama

https://www.youtube.com/watch?v=SBGpr1fPyb4

TLDR AI coding agents are advancing quickly and can outperform people on specific, well-defined tasks, but autonomous software engineering remains far off because architecture, long-term reliability, and unclear requirements are hard to judge. Teams should use agents to boost productivity and improve code quality while relying on experienced developers to guide them, catch mistakes, manage technical debt, and make sound design decisions.

Key Insights

1. Measure coding agents beyond benchmark scores

Benchmarks such as SWE-Bench can show whether an agent completes specific, verifiable coding tasks, but they capture only part of software engineering. Real projects also require deciding what to build, clarifying expected behavior, and choosing designs that can evolve. Treat benchmark results as evidence of progress, not proof that an agent can independently deliver and maintain a complete software system. Evaluate tools against the actual needs and risks of your work.

2. Start with clear, testable tasks

Coding agents are best suited to work with outcomes that can be checked quickly, such as implementing a well-specified change or running a focused test suite. Ambiguous requirements and architectural choices are harder to automate because their consequences may emerge much later. Break larger projects into smaller tasks with explicit acceptance criteria, tests, and review points. This makes it easier to verify results and catch errors before they spread.

3. Keep experienced developers involved

Human expertise remains essential for interpreting stakeholder needs, reviewing design choices, and recognizing when an agent is heading in the wrong direction. Early mistakes can compound into costly dead ends, especially in complex or long-running projects. Experienced developers can use agents effectively because they are better equipped to identify problems, correct course, and judge whether generated code fits the system. Preserve opportunities for team members to build the skills needed to supervise AI-assisted development.

4. Design agent workflows and interfaces deliberately

AI agents do not work exactly like human developers, so simply placing them into existing processes may limit their effectiveness. Give agents clear responsibilities, reliable tools, and well-documented interfaces; for example, a separate review agent can assess code independently of the original implementation. Human guidance is still needed to configure these workflows and coordinate handoffs. Over time, tools designed specifically for agents could expose information and capabilities that conventional human-focused interfaces hide.

5. Use AI to improve software quality, not just output volume

Faster code generation can increase technical debt if teams prioritize shipping more features over maintaining sound systems. Agents can also help with substantial refactoring, code cleanup, and reliability or security improvements—work that can be meticulous and time-consuming for people. Decide deliberately whether productivity gains will support durable quality or a cycle of rapid, fragile changes. Include maintenance and technical-debt reduction in the plan from the start.

6. Expect higher standards and plan migrations carefully

As AI makes software production more efficient, users and organizations are likely to expect more polish, sophistication, and reliability. Increased productivity therefore does not automatically mean teams can reduce staffing or skip careful review. For major migrations, such as modernizing a high-throughput banking system, translating existing code is not enough: teams must preserve critical behavior while redesigning and changing the system safely. Plan for testing, continuity, and long-term maintenance alongside implementation.

Questions & Answers

What do coding-agent benchmarks such as SWE-Bench tell us about AI’s progress in software engineering?

They measure real progress on specific, checkable coding tasks, but cover only a small part of software engineering. Building software also involves deciding what to build, anticipating its behavior, and choosing designs that can support future change.

Why is it difficult to determine whether autonomous software engineering has arrived?

There is no single benchmark that can establish this. Tasks with clear, easily checked outcomes are relatively easy to automate, while architectural choices may seem successful at first but cause problems years later. Ambiguous requirements and long-term consequences are also difficult to measure.

What are some important limitations of current AI coding agents?

They struggle with long-horizon work, such as distributed systems whose failures emerge only at scale. They also have difficulty resolving ambiguous stakeholder needs, retaining experience through lifelong learning, and replacing the social rapport involved in human collaboration.

How should organizations and small businesses approach adopting coding agents?

They should recognize that the tools are powerful but require a substantial learning curve. Developer expertise remains essential, and experienced users can often use agents especially effectively. Organizations should preserve opportunities for people to develop that expertise rather than assuming agents make it unnecessary.

Will AI coding agents allow organizations to reduce staffing?

Not necessarily. Agents are likely to increase productivity, but they will also raise expectations for software quality, polish, and sophistication. Teams should not assume that higher productivity simply means fewer people are needed.

Why does human expertise remain important when agents make mistakes?

Early mistakes can compound and send an agent down a dead end. People with relevant expertise can recognize wrong turns, correct them, and help the agent backtrack. In an MIT student project, students with more expertise made greater progress partly because they could identify problems.

How can multi-agent systems collaborate effectively?

They can be powerful when designed carefully, with clear roles and controlled context. For example, a reviewer agent can assess code without seeing the original intent, encouraging an independent evaluation. Effective collaboration also depends on clean, well-documented interfaces and skillful setup by people.

Why is modernizing a COBOL banking system more than translating its code?

A useful migration requires redesigning the system, not just preserving local behavior in another language. Banking systems must also be changed safely while maintaining high throughput and reliability without interrupting service.

What is neurosymbolic AI, and why is it useful?

Neurosymbolic AI combines language models, which are strong at informal reasoning and communication, with symbolic tools such as calculators and theorem provers. Those tools can perform precise tasks more efficiently and reliably.

How could AI coding tools affect technical debt?

They could make technical debt accumulate quickly by making it easy to produce more code. However, newer models can also help with major refactoring, improving code structure, and creating more reliable and secure software.

How should organizations use AI to address technical debt?

Organizations must choose whether to use AI for lasting improvements in quality or to rapidly produce frequently changing, sometimes unreliable applications. The long-term winners are likely to be those that deliberately invest in improving their products.

Summary of Timestamps

Coding-agent benchmarks such as SWE-Bench measure genuine progress, but they cover only a small part of software engineering. Building software also means deciding what to build, anticipating how it should behave, and choosing designs that can adapt over time. Since AI agents have different strengths and weaknesses from human developers, the central challenge is organizing people and agents to work effectively together—not simply replacing people.

Program synthesis uses methods such as automated reasoning, formal methods, and machine learning to generate code or reduce the need to write it by hand. Professor Armando describes a field that grew from formal methods to include language models trained on large collections of code, including student assignments. Progress has been remarkable, but the field remains far from solved.

There is no single benchmark that can establish that autonomous software engineering has arrived. Tasks with clear, easily checked outcomes are more likely to be automated quickly because models can be trained against measurable rewards. Architectural choices are harder to evaluate: a design may seem successful at first but cause problems years later.

Current models struggle with long-horizon challenges such as distributed systems, where failures may emerge only at scale and be difficult to reproduce. Software work also requires turning ambiguous stakeholder wishes into practical, testable specifications—another task that is hard to benchmark. Models also lack lifelong learning: they do not reliably retain experience and apply it to new problems as people do.

Coding agents can be powerful, but small businesses and developers face a substantial learning curve. Expertise remains crucial, especially when users need to recognize errors or guide an agent through a difficult task; experienced developers may get more out of these tools. Organizations should preserve opportunities for people to build that expertise rather than assume staffing can simply be reduced.

AI is likely to increase productivity, but it will also raise expectations for software quality, polish, and sophistication. Just as standards for websites have risen over time, users may come to expect more capable and refined applications. Teams should plan for higher standards, not assume that productivity gains automatically mean less work or fewer people.

Today’s agents are being adapted to use interfaces designed for humans, but a longer-term opportunity is to create tools and interfaces specifically for agents. Such tools could expose detailed error messages or other information that human-oriented interfaces hide. Designing around agents’ distinct capabilities may help them work more effectively.

Early mistakes by an agent can compound and lead a project down a dead end, so human expertise is still important for spotting wrong turns and correcting them. In an MIT student experiment involving an AI-assisted gastro bot, students with more expertise made greater progress in part because they could identify problems and backtrack.

Multi-agent systems can be effective when designed carefully, especially when their context is controlled. For example, a code-review agent can be kept unaware of the original intent so it evaluates the code independently. The discussion raises—but does not fully resolve—the question of whether current multi-agent systems can reproduce genuine teamwork.

Agents can imitate aspects of software teams, but successful collaboration depends on clean, well-documented interfaces and skilled setup by people. Legacy modernization illustrates the limits of simple code generation: migrating COBOL banking systems means more than translating code. A useful migration must redesign systems while preserving reliability and avoiding interruptions to high-throughput services.

Neurosymbolic AI combines language models’ strengths in informal reasoning and communication with symbolic tools such as calculators and theorem provers. These specialized tools can handle precise tasks more efficiently and reliably. The combination points toward systems that use language models for flexible work while relying on formal tools where accuracy is essential.

AI coding tools could make technical debt accumulate faster by making it easy to produce code quickly. But models have also improved at major refactoring and can help teams improve structure, security, and reliability, including by taking on meticulous work that developers may dislike or find difficult.

Organizations must decide whether to use AI’s productivity gains to create lasting quality or to pursue a “fast fashion” approach that constantly produces changing, sometimes unreliable applications. The long-term winners are likely to be those that deliberately invest in improving their products. The speakers close by agreeing that reducing technical debt should become faster and cheaper, and thanking Professor Armando for the conversation.