DavidKeys.com

The way software is created may be undergoing one of its biggest transformations since the invention of modern programming languages.

David Fowler, a Microsoft Distinguished Engineer and longtime contributor to the .NET ecosystem, recently made a blunt prediction about the future of software development: “Typing code is absolutely over.” Fowler made the statement on X on September 3, 2026, reigniting debate about whether artificial intelligence is fundamentally changing what it means to be a programmer. (HotHardware)

While the statement sounds like a prediction that programmers are disappearing, that’s not necessarily what Fowler is suggesting. Instead, it points toward a future in which developers spend far less time manually writing individual lines of code and far more time directing, reviewing and testing software generated by AI.

AI Is Changing How Developers Write Software

For decades, software development has followed a familiar process: programmers write code in an editor, compile it, test it, identify problems and repeat the process.

AI coding tools are disrupting that workflow.

Modern AI systems can generate functions, create entire applications, explain existing code, identify bugs and make changes across multiple files. Increasingly sophisticated AI coding agents can also take a high-level assignment and perform multiple development tasks with limited human intervention.

That means the keyboard may no longer be the primary tool for creating software.

Instead, developers can describe what they want, provide the necessary context and allow AI systems to produce much of the implementation.

The developer then becomes responsible for determining whether the result is correct.

David Fowler’s Perspective Carries Weight

Fowler isn’t a newcomer making predictions about software development. He has spent roughly 18 years at Microsoft and has played an important role in the .NET ecosystem.

His work includes technologies such as SignalR, Kudu and NuGet, and he currently works on .NET Aspire, according to reporting surrounding his comments. (HotHardware)

That background makes his statement particularly notable.

When an experienced software engineer says manual code entry is becoming obsolete, the argument isn’t necessarily that programming knowledge is no longer valuable. Instead, it reflects a shift in where that knowledge is applied.

The important skill may increasingly be telling machines what software should accomplish rather than manually explaining every individual step through code.

Coding Isn’t Dead — But the Job Is Changing

The phrase “typing code is absolutely over” can easily be interpreted as “software engineers are finished.”

That’s a much bigger claim.

AI can generate code quickly, but generated code still needs to work correctly. It must be secure, maintainable, scalable and compatible with existing systems.

Human engineers remain important for decisions involving:

• Software architecture
• Security
• Performance
• System integration
• Requirements
• Testing
• Debugging
• Reliability
• Business logic
• Long-term maintenance

In other words, AI may eliminate much of the typing without eliminating the engineering.

The distinction is important.

A developer who understands how software works can evaluate AI-generated code. Someone who doesn’t understand programming may have difficulty recognizing when an AI-generated solution is subtly wrong.

From Programmers to AI Supervisors

The emerging development model looks increasingly different from traditional programming.

Instead of spending hours writing thousands of lines of code, a developer might:

1. Define the desired outcome.
2. Give an AI agent access to the relevant project context.
3. Ask the agent to implement the feature.
4. Review the generated changes.
5. Run automated tests.
6. Identify problems and ask the agent to correct them.
7. Approve and deploy the finished work.

This approach moves developers toward a supervisory and architectural role.

The developer becomes less of a code typist and more of a technical director.

That doesn’t necessarily make software development easier. In some cases, it could make it more demanding because developers will need to understand larger systems and make better decisions about what AI should and shouldn’t be allowed to do.

Microsoft Is Already Embracing AI-Assisted Development

The change isn’t merely theoretical.

Microsoft has increasingly incorporated AI into its software development ecosystem, including AI-powered coding and development agents. Reporting on Fowler’s comments also points to Microsoft’s broader use of AI-generated code and automated development workflows. (HotHardware)

The company’s direction reflects a larger industry trend: AI is moving from being a simple autocomplete tool toward becoming an active participant in the development process.

Traditional autocomplete might suggest the next few lines.

An AI agent can potentially work on an entire task.

That’s a significant difference.

What Happens to Junior Developers?

One of the biggest unanswered questions involves people entering the software industry.

Historically, junior developers learned by writing code. They gained experience by building small applications, fixing bugs and gradually taking on more complicated projects.

If AI handles much of that entry-level work, companies and educators may need to rethink how new programmers develop their skills.

There is a potential danger here.

If inexperienced developers rely on AI without understanding fundamental programming concepts, they may become highly dependent on systems they don’t fully understand.

The next generation of developers may therefore need to learn how to think like engineers before learning how to use AI coding tools effectively.

The Rise of “Agentic” Software Development

The trend is part of a broader movement sometimes described as agentic software development or agentic engineering.

Rather than simply asking AI to generate a snippet of code, developers can increasingly delegate larger tasks to autonomous or semi-autonomous agents.

The shift has already generated predictions that traditional software development workflows will change dramatically. Industry discussions increasingly emphasize system design, task decomposition, testing, verification and managing AI agents rather than manually producing every line of code. (Flowkater.io)

That could eventually make software development accessible to people who don’t have extensive programming backgrounds.

But accessibility comes with a trade-off: generating software becomes easier while ensuring that the software is good becomes increasingly important.

Is the Keyboard Really Becoming Obsolete?

Probably not — at least not completely.

Developers will still type code when AI produces something incorrect, when a particularly complex problem requires manual intervention or when a programmer wants precise control over an implementation.

But the amount of code humans manually type could decline dramatically.

Think of it like the transition from assembly language to higher-level programming languages. Developers didn’t stop programming when abstractions improved. They simply moved to a higher level.

AI may represent another abstraction layer.

Instead of telling a computer exactly how to perform every operation, developers increasingly tell an AI system what they want built and then verify the result.

The Future of Programming May Be About Thinking, Not Typing

Fowler’s provocative statement captures a larger change happening across the technology industry.

The most valuable programming skill of the future may not be the ability to type code quickly.

It may be the ability to understand a problem, design an effective solution, communicate that solution to AI systems and determine whether the resulting software actually works.

In that sense, the era of coding may not be ending. The era of manually writing most of the code may be.

AI won’t necessarily eliminate software engineers.

Instead, it could transform them into something closer to architects, problem solvers and managers of intelligent development systems.

And if that transformation continues, the next generation of programmers may look back at manually typing thousands of lines of code the way today’s developers look back at punch cards.

The Bottom Line

Microsoft Distinguished Engineer David Fowler’s declaration that “typing code is absolutely over” is intentionally provocative, but it reflects a genuine shift in software development. AI coding agents are rapidly moving from simple assistants to tools capable of handling increasingly large portions of the development process. (HotHardware)

The programmer isn’t necessarily disappearing.

The programmer’s job is changing.

And the most important question may no longer be “Can you write the code?”

It may soon be:

“Can you tell an AI what to build — and know when it got it wrong?”