I've been developing software and reviewing code for more than 30 years, and today an AI coding agent can generate thousands of lines in a few minutes. I'll be honest: I rarely read every line anymore. I review the specification, go through the implementation plan, and spot-check the generated code.
It works, but something about this process makes me increasingly uncomfortable. We are becoming responsible for software we haven't fully read, written by agents whose implementation decisions we don't always understand.
The specification tells us what we want to build and the plan describes how the agent intends to approach it, but neither one captures all the decisions that end up determining how the software actually behaves.
So as AI-generated code becomes the norm, I keep coming back to a basic question: at what level should humans understand, review, and control software?
Introducing ANDL
I've been exploring an idea I call Agent-Native Descriptive Language, or ANDL. The idea is to add a layer between the specification and the executable source code: a structured, human-readable description of the actual implementation, somewhere between structured pseudocode and an executable specification, designed for humans and AI coding agents working together.
An ANDL description would capture implementation decisions, control flow, data transformations, error handling, and the behavioral constraints that matter. Engineers could read it, review it, and change it, and agents could translate it into Rust, Python, Go, TypeScript, or whatever language the project needs.
Take an order-processing service. The requirement may simply say "skip duplicate orders." But what counts as a duplicate? What happens when two identical orders arrive at the same time, or when the first request fails halfway through? What should the second request return? Those are not minor details, they define how the system behaves. ANDL would make those decisions explicit and reviewable before the agent writes the production code.
A musical score for software
As a musician, I keep thinking about musical notation when I look at this problem. A score describes a composition independently of the instrument that plays it. It captures structure, timing, relationships, and intent, and different musicians can perform it on different instruments while keeping what is essential. I picture ANDL working in a similar way: the implementation description is the score, programming languages are the instruments, and AI agents are the performers.
Software obviously needs much stricter guarantees than a musical interpretation, which is why verification has to be part of the picture. Still, the principle holds: the representation humans use to understand software doesn't have to be the same one machines execute.
Beyond code review
Code review is the immediate motivation. Instead of going through thousands of generated lines, engineers would review the decisions that matter, while automated verification helps confirm the code follows them.
But I think the implications go further. A team could refactor at the descriptive level and regenerate the affected code. Migrating a service from Python to Rust could mean carrying over a reviewed description instead of reconstructing behavior from thousands of lines of source. Code review could focus on changes in behavior, leaving line-by-line inspection for the places where it's still needed.
Over time, the main artifact of software development might shift from language-specific source code toward something both humans and agents can understand and work with. Source code wouldn't disappear, but the level at which engineers design and keep control of software would change. That is the possibility that really interests me.
Isn't this just pseudocode?
Fair question. We already have pseudocode, formal specifications, design by contract, intermediate representations, and model-driven development, and ANDL should build on those ideas rather than pretend they don't exist. What I think is new is combining them inside an agent-native workflow.
An ANDL description needs to be readable enough for engineers to understand and challenge the decisions, precise enough for agents to generate code without much ambiguity, language-independent where that's practical, verifiable so we can detect when the generated code drifts from it, and maintainable as the system evolves. Coming up with a notation is the easy part.
The hard part is finding the right level of abstraction between high-level requirements and source code.
The hard problems
There are three problems I haven't solved.
-
The first is precision versus readability: how to describe behavior precisely enough to keep the important semantics without ending up with something as complex as the code itself.
-
The second is verification: how to show that a generated implementation actually conforms to its description, especially under concurrency, failures, and unexpected conditions.
-
The third is synchronization: if engineers or agents change the generated code directly, how do we detect the divergence and keep the description trustworthy?
These are serious engineering and research problems and I don't expect them to be easy, but I think they're worth working on.
The bigger question
For decades, programming languages have been the main medium through which we express implementations and understand how software works, and AI agents are starting to change that relationship. When machines generate production code faster than people can reasonably read it, better review tools may not be enough.
We may also need a better representation of software itself, one that keeps humans responsible for the architecture, the decisions, and the behavior of what they build, even when agents write most of the code. Writing code and engineering software may be turning into increasingly different activities, and ANDL is my attempt to explore what that difference could look like.
It's an early idea, not a finished solution. I'd especially welcome criticism from people working on compilers, formal methods, program synthesis, or AI coding agents.
What am I missing? And would you be interested in helping explore it?
Frequently asked questions
What is Agent-Native Descriptive Language (ANDL)?
Agent-Native Descriptive Language (ANDL) is a concept Luis Paradela is exploring to describe software implementations in a structured, human-readable format. Engineers could review and edit that description, and AI agents could translate it into source code.
Why is reviewing AI-generated code a challenge?
AI agents can generate code faster than engineers can thoroughly review it. Specifications and plans may leave implementation decisions unexplained. ANDL aims to make the decisions that determine software behavior explicit and reviewable.
How would ANDL differ from pseudocode or software documentation?
ANDL would describe control flow, data transformations, error handling, and behavioral constraints with enough precision to guide code generation. It would also require ways to verify that the code follows the description and detect differences as the software evolves.
How could ANDL help teams maintain control of their software?
ANDL could provide a shared, readable record of implementation decisions. Teams could use it to review behavioral changes, transfer knowledge, refactor software, and support migrations between programming languages, subject to verification.
Is ANDL ready for production use?
ANDL is an early idea under exploration. Its main challenges are balancing precision with readability, verifying that generated code follows the description, and keeping both synchronized as changes are made.