The Last Typist: Why we need integrated software development

The typing was never the work of Software Engineering.

The old craft

Software used to be slow. It was slow because people were slow. People were the only machinery we had to produce it.

An idea went to an analyst. The analyst wrote a requirement. The requirement went to an architect. The architect drew boxes. The boxes went to developers. The developers typed. Reviewers read. Testers tested. Security looked last. Compliance looked later. Each handoff lost something. Meaning leaked out at every seam.

We called this a process. It was a relay race run in fog with ill-defined tracks.

The cost followed the shape. Writing code was perhaps a third of the effort. The rest was waiting, explaining, rework and repair. A defect found in production cost many times what it cost at the dev machine. Everyone knew this. We built ceremonies around it to fix this. Standups. Sprints. Gates. They helped. They did not change the physics. Humans typed. Humans checked. Humans missed things.

The mistake

Then the machines arrived. They could write code. Fast. Fluent. Tireless.

So we did the obvious thing. We handed them to the old process. A copilot for each developer. A chatbot in the ticket queue. A faster typist at the same desk.

It felt like progress. Often it was not. One controlled study in 2025 found experienced developers slower with ad hoc AI help on mature codebases. The code came faster. The review, the correction and the doubt came slower. The bottleneck moved. Nobody moved with it.

This is the pattern. A new engine bolted onto an old carriage. The carriage sets the speed. The wheels were never built for more.

The old process assumed code was scarce, difficult to produce. So it rationed code. Code is now abundant, and this abundance breaks every one of the old processes. Reviews drown. Test suites rot. Architecture drifts, one plausible patch at a time. Add AI to that process and you get more of everything, including error, delivered faster.

Or you get nothing. The team learns to distrust the output and retypes it by hand. The power is there. It is simply never switched on.

The new process

Start from a different question. Not how do I help developers type faster? But what is software, and what does it take to make it in high quality?

Software is a decision made precise. It is domain knowledge, compressed into rules a machine can obey. The code is the last step. The knowledge is the first. If the knowledge is wrong, perfect code is perfectly wrong.

So the new process starts there. A person who truly knows the domain states the intent. The constraints. The invariants. What must never happen. What the law requires. What the user fears. This is the real source. Everything else is derived.

Then agents work in a chain, each with one job.

• Analysis: turns intent into a precise specification and hunts for gaps and contradictions.
• Design: proposes the architecture and records why.
• Coding: writes the implementation against the specification.
• Verification: checks code against specification, by proof or property where it can, by reading where it cannot.
• Testing: writes tests from the specification, not from the code, so the two cannot share one mistake.
• Security, privacy, compliance: check every change against policy as it is made.
• Human expert: reviews what matters. Decisions. Trade-offs. Surprises.

The key words are by design. Security is not a phase at the end. It is a constraint in the specification. Privacy is a property checked on every commit. Compliance is a living map from regulation to test. Testing is born with the requirement, not after the code. Each check is cheap now, so each runs always. What was audited quarterly is verified continuously.

Every claim leaves a trace. Requirement to design to code to test to evidence. An auditor can walk it. So can an engineer at midnight.

This is not a better tool. It is a different factory. This is the need of the hour.

The numbers

An estimate: a well-run integrated pipeline cuts human effort by 60 to 75 percent and total cost by 50 to 70 percent. Calendar time falls further. Escaped defects fall by half or more.

Measure (index, classical = 100)	Classical process	Integrated agentic process	Why
Human effort	100	25–40	Coding, test writing, documentation and rework move to agents
Total cost, incl. model usage and tooling	100	30–50	Inference is cheap against salaries; expert time stays
Calendar time to release	100	15–35	Parallel agents, no handoff waits
Defects escaping to production	100	20–50	Tests from the specification, continuous verification
Security and compliance fixes found late	100	10–30	Checked on every change, not at the end
Share of human effort on domain and specification (%)	about 25	about 60	Work shifts from typing to intent and judgement

These are informed estimates, not measurements. They assume a mid-sized system, a well-understood domain and strong expert input. Cost falls less than effort because models, tooling and scarce experts are still paid for. The savings sit in coding, testing, documentation, rework and late fixes. They do not sit in understanding the problem. That cost stays. It becomes the main cost.

What remains

The typist is leaving. Good. The typist was never the point.

What stays is the person who knows. The clinician who understands the ward. The engineer who knows how a system fails. The lawyer who knows what a clause costs. They will write less code and decide more. Their errors will matter more, because the machine will faithfully build them.

So the discipline changes. Less craft of syntax. More craft of intent. Less heroism. More evidence.

The old process fails if you add AI to it. The new one fails if you leave out the knowledge. Software was always thought, made solid. We are finally free to work on the thinking.