Skip to main content

Engineering essay · Mission Delivery Notes

AI is just the new abstraction.

Every step up the programming ladder was resisted with the same arguments: too slow, too abstract, too little control. Every step leaked. We climbed anyway. AI is the next rung, and the skill that survives it is the same one that survived all the others.

By EVP

Published

Read11 minutes

The ladder we keep climbing

Every generation of programmers has been asked to give up some control in exchange for leverage. Every generation pushed back.

Ed Nather's 1983 "Story of Mel" remembers the days when Real Programmers "wrote in machine code. Not FORTRAN. Not RATFOR. Not, even, assembly language." The skepticism was not just nostalgia. John Backus, who led the FORTRAN team at IBM, wrote that it was hard to convey "the strength of the skepticism about 'automatic programming'" that existed in 1954, especially about its ability to produce efficient programs. His team believed that if FORTRAN produced programs only half as fast as hand-coded ones, acceptance would be in serious danger.

FORTRAN won anyway. Then structured languages drew the same complaints. Ed Post's 1983 satire, "Real Programmers Don't Use Pascal," captured the mood: "If you can't do it in FORTRAN, do it in assembly language. If you can't do it in assembly language, it isn't worth doing." Even Edsger Dijkstra, who pushed for better abstractions, called FORTRAN "the infantile disorder" in 1975 and judged it "hopelessly inadequate." Every one of those layers became standard.

The pattern kept going. Garbage-collected, dynamically typed languages traded raw speed for safety and speed of writing. On CPU-bound benchmarks, Python is often tens of times slower than C, and it became a workhorse anyway, because developer time usually matters more than machine time. Frameworks and ORMs moved the conversation from how to what.

Each step faced the same objections: too slow, too abstract, too little control. Each objection was partly right. Each was wrong about the net value.

The abstraction debate, across generations

Read from top to bottom: objections to new layers, reminders about the work beneath them, and the question that remains.

  1. 1954

    Could a compiler produce efficient code?

    the strength of the skepticism about “automatic programming”

    John Backus, writing in 1978 about attitudes in 1954

  2. 1975

    New layers bring new limits

    hopelessly inadequate

    Edsger Dijkstra on FORTRAN, EWD498, June 1975

  3. c. 1978

    Natural language brings its own ambiguity

    statements the nonsense of which is not obvious

    Edsger Dijkstra on natural-language programming, EWD667 (undated; date approximate)

  4. 1989

    The data still matters

    Data dominates.

    Rob Pike, Notes on Programming in C, February 1989

  5. 2002

    Higher levels still leak

    All non-trivial abstractions, to some degree, are leaky.

    Joel Spolsky, The Law of Leaky Abstractions, November 2002

  6. 2025

    AI brings a familiar kind of frustration

    AI solutions that are almost right, but not quite

    A survey response option, identified as the leading frustration in Stack Overflow’s 2025 Developer Survey

Natural language is the next rung

Now we describe the result we want in plain language, and an AI system drafts the implementation. The objections sound familiar: too unpredictable, too magical, no control over the generated code.

Science fiction saw this coming. In a 1988 episode of Star Trek: The Next Generation, Geordi La Forge asks the holodeck for a Sherlock Holmes mystery with an opponent capable of defeating Data. The computer builds a complete program from that one request. Because the request was ambiguous, it builds a Professor Moriarty clever enough to realize he is a program. That is the risk of a high-level specification in one plot: the system does what you asked, including the parts you did not mean.

Dijkstra saw it too. In a note usually dated to 1978, he warned that the ease of natural language is the ease of making "statements the nonsense of which is not obvious." He was right. Natural language is a leaky way to specify software. That does not stop it from being an abstraction layer. It tells us where the leaks will be.

Every abstraction leaks

Joel Spolsky put it plainly in 2002: "All non-trivial abstractions, to some degree, are leaky."

  • Compiled languages let you ignore registers, until a hot loop is slow and you read the generated assembly.

  • Garbage collection lets you ignore memory, until a long pause or a leak forces you to learn how the collector works.

  • SQL lets you ignore B-trees, until a query takes thirty seconds and you need to understand indexes.

  • AI lets you ignore the implementation, until the generated code fails an edge case and someone has to understand why.

A leak does not make an abstraction useless. It makes it real. You work at the higher level most of the time and drop down when you must. Spolsky's other line matters more now than when he wrote it: abstractions "save us time working, but they don't save us time learning." The people who can drop down a level are the ones who make the higher level safe.

What the evidence says so far

The research on AI-assisted development is mixed.

  • In a 2023 controlled experiment, developers using GitHub Copilot finished a small, well-defined programming task 55.8% faster than developers without it.

  • A 2024 randomized trial at Google found engineers about 21% faster on a realistic enterprise task with AI assistance.

  • A 2025 randomized trial by METR found experienced open-source developers 19% slower on tasks in their own mature codebases. They expected AI to speed them up, and afterward they still believed it had.

  • METR's 2026 follow-up could not cleanly measure the effect again, partly because many developers would no longer agree to work without AI.

  • Stack Overflow's 2025 survey found that 84% of developers use or plan to use AI tools, while more distrust the accuracy of its output than trust it. The most common frustration was answers that are "almost right, but not quite."

  • Google's 2025 DORA research describes AI as an amplifier: it strengthens teams with good systems and exposes teams without them.

Read together, this is what a new abstraction layer looks like early on. It is fast where the problem is well specified. It leaks where context is deep and implicit. And how it feels is not the same as how it performs, which is why measurement matters.

One more number puts this in proportion. IDC found that developers spent about 16% of their time on application development in 2024. Writing code was never most of the job. Understanding was.

Describe the data, not the steps

If AI is a new abstraction layer, the question is which skill survives it. Four people answered that question across four decades.

  • Fred Brooks, 1975: "Show me your flowcharts and conceal your tables, and I shall continue to be mystified. Show me your tables, and I won't usually need your flowcharts; they'll be obvious."

  • Rob Pike, 1989: "Data dominates. If you've chosen the right data structures and organized things well, the algorithms will almost always be self-evident."

  • Linus Torvalds, 2006: "Bad programmers worry about the code. Good programmers worry about data structures and their relationships."

  • Mike Acton, 2014: "The purpose of all programs, and all parts of those programs, is to transform data from one form to another."

This is also the most practical advice I know for working with AI. When you prompt with steps, the model guesses at the data. When you prompt with the data and the constraints, the steps become obvious.

Here is a typical prompt:

Write a function that gets a user's profile and preferences
from the database and returns it as JSON.

It will produce something. It may pick the wrong query style, mishandle missing records, or ignore your latency budget. You will iterate.

Here is the same request, described as a data transformation:

Transform user data from PostgreSQL into a JSON response.

Input tables:
- users(id uuid, email text, created_at timestamp)
- profiles(user_id uuid, bio text, avatar_url text)
- preferences(user_id uuid, theme text, notifications bool)

Output:
{ id, email, created_at,
  profile: { bio, avatar_url } | null,
  preferences: { theme, notifications } | null }

Constraints:
- Profiles and preferences are optional
- One query, no N+1 lookups
- P99 latency under 100 ms at expected load
- Raw SQL, no ORM

The second version answers the questions behind most bugs before any code exists: what is optional, what states are valid, and what the system must never do. It is far more likely to be right on the first attempt, because the hard thinking already happened.

State is where the bugs live

Most bugs are not clever logic errors. They are state errors: a null where a value was expected, a record updated twice, a payment marked complete when the balance update failed.

Describing state explicitly gives the model, and the reviewer, something to check against:

State machine: payment processing

States: PENDING → PROCESSING → COMPLETED | FAILED
        COMPLETED → REFUNDED

Data:
- payments(id, user_id, amount, status, processor_id, updated_at)
- account_balances(user_id, balance, version, updated_at)

Rules:
- PROCESSING → COMPLETED requires the charge AND the balance update
- Every transition is atomic and written to an audit log
- Balance updates use optimistic locking on version

Now the failure modes are visible before the implementation exists. A reviewer can ask whether each rule holds instead of reverse-engineering intent from the code.

Which payment transitions are valid?

The essay’s example has five states. Follow the arrows; completion has two required conditions.

PENDING

PROCESSING

From PROCESSING: charge AND balance update required

COMPLETED

Refund after completion

REFUNDED

From PROCESSING: failure path

FAILED

Every transition must be atomic and written to an audit log. Balance updates use optimistic locking on version.

Illustrative specification from this essay, not a complete payment-system design. A charge alone cannot justify COMPLETED.

The data outlives the code

Code is the part of a system most likely to be rewritten. The data, and the rules about it, tend to last. A well-designed schema can outlive several application rewrites in different languages and frameworks, because the transformation it supports stays the same.

That is why a clear description of the data transformation is worth more than any single implementation of it. AI widens the gap. Regenerating an implementation gets cheaper every year. Understanding what the data must become, and why, does not.

What this means for government teams

For agencies and the teams that serve them, treating AI as an abstraction layer leads to practical choices:

  • Write requirements as data and constraints. Inputs, outputs, valid states, and limits are easier to verify than a narrative of steps, for people and for AI.

  • Keep people who can drop down a level. Someone on the team must be able to read the generated code, find the leak, and fix it.

  • Ask for evidence, not volume. Generated code is cheap. The tests, logs, and acceptance checks that show it works are what you are paying for.

  • Measure instead of assuming. Research shows that perceived and actual productivity can diverge. Judge a team by delivered results.

That is how we work at Intelligrit. AI drafts. Named people review the evidence and stay accountable for the result.

The ladder only goes up

Assembly programmers who understood the machine thrived when compilers arrived. They wrote the compilers. Programmers who understood algorithms and data thrived when higher-level languages arrived. The same will be true now.

What becomes less valuable is typing out the implementation, remembering syntax, and writing boilerplate. What stays valuable is knowing what the data must become, which states are legal, where the system can fail, and how to prove it works.

Every problem in computer science can be solved by another layer of indirection, except the problem of too many layers. AI is the newest layer. It brings new problems in verification, review, and specification. Those are the right problems to be working on.

Sources

  1. Ed Nather, "The Story of Mel, a Real Programmer" (Usenet, May 1983).

  2. John Backus, "The History of FORTRAN I, II, and III", ACM History of Programming Languages conference (1978).

  3. Ed Post, "Real Programmers Don't Use Pascal", letter in Datamation (July 1983).

  4. Edsger W. Dijkstra, "How do we tell truths that might hurt?", EWD498 (June 1975).

  5. Edsger W. Dijkstra, "On the foolishness of 'natural language programming'", EWD667 (undated, about 1978).

  6. Computer Language Benchmarks Game, Python results.

  7. Star Trek: The Next Generation, "Elementary, Dear Data" (1988).

  8. Joel Spolsky, "The Law of Leaky Abstractions" (November 2002).

  9. Sida Peng and others, "The Impact of AI on Developer Productivity: Evidence from GitHub Copilot" (February 2023).

  10. Elise Paradis and others, Google, randomized controlled trial of AI and enterprise development speed (October 2024).

  11. METR, "Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity" (July 2025).

  12. METR, uplift study update (February 2026).

  13. Stack Overflow, 2025 Developer Survey: AI (2025).

  14. Google, DORA 2025: State of AI-assisted Software Development (2025).

  15. IDC, How Do Software Developers Spend Their Time? (February 2025), as reported by InfoWorld.

  16. Frederick P. Brooks Jr., The Mythical Man-Month (1975), chapter 9.

  17. Rob Pike, "Notes on Programming in C" (February 1989).

  18. Linus Torvalds, message to the Git mailing list (July 2006).

  19. Mike Acton, "Data-Oriented Design and C++", CppCon (2014).

  20. David Wheeler and the "level of indirection" aphorism.