The pyramid sorts the ways of building software with AI by how much of the engineering you take on. Six categories do not fit that sort. They are not rungs. They apply on every rung, and placing one on a single rung would tell you something false about when it matters.
Code review is the clearest case. It is more urgent at the top of the pyramid than at the bottom, because more of the code was written by something other than you. It never stops applying, though, and a rung of its own would suggest you could climb past it.
The six practices
Cloud development environments. The work runs on a machine somewhere else, with no local setup, and delegated agents increasingly run there too. For a developer on a low-end laptop, a patchy connection or unreliable power, moving the environment off the machine is not a convenience. It is what makes the work possible. What it costs later: a dependency on your machine becomes a dependency on a connection and a provider, your code and secrets live on someone else's hardware, and the environment's configuration is one more thing to keep in the repository and maintain.
AI testing and debugging. Generating tests, reading stack traces, reproducing a failure, proposing a fix. Undersold, and the category that makes every rung safer. What it costs later: a test generated from the implementation asserts what the code does, not what it should do, so a green suite can confirm a bug. Tests written from the requirements, and property-based tests for the edge cases that example tests miss, are what keep it honest.
AI DevOps and cloud engineering. Containers, pipelines, infrastructure and monitoring: the move from building software to running it. What it costs later: generated pipeline and infrastructure configuration runs with real credentials against real systems, so a mistake there is an outage or a bill rather than a failing test. Review it as carefully as code that touches money.
AI code review, refactoring and maintenance. Understanding an existing codebase, finding technical debt, upgrading dependencies, documenting what nobody documented. Professional work is mostly not greenfield. It is maintaining something someone else built, and some of that someone else is now a model. What it costs later: an automated first pass can make a review feel finished when the part that needed judgement was never looked at. Let it summarise and flag, and keep the call on design, security and whether the change belongs with a person. Code review is the new bottleneck is the longer argument.
Voice and conversational coding. Speaking the work rather than typing it. Useful for planning, where thinking runs ahead of the keyboard, and important for anyone whose hands make sustained typing painful. What it costs later: dictated technical terms come out mangled, punctuation is hard to control, and everything spoken needs editing as text afterwards. It works best for a first draft of a plan or a specification, not for the code itself.
Reverse engineering and cloning. Recreating an existing product from its interface or its observed behaviour. It exists, and the line between studying a pattern and copying a product is thinner than the people doing it tend to admit. What it costs later: exposure to copyright and trade dress claims, and a product whose premise belongs to someone else. For those reasons it is declined as a course. The legitimate half, understanding an unfamiliar system and turning a design into an interface, is the same skill taught through code review and through design to code. Learn from interfaces. Do not ship someone else's.
Where each one starts to matter
None of these is tied to a rung, but most of them become more pressing as you climb.
- Testing and review grow with the share of code you did not write. On the lowest rungs they are about the finished result. From Agent in the editor upward they are about every change.
- DevOps matters from the moment something has to stay running, whichever rung built it.
- Cloud environments matter when your machine, your power or your connection is the constraint, and when delegated agents need somewhere to run.
- Voice matters when typing is the constraint.
- Reverse engineering does not become a better idea higher up.
Two that sit on rungs instead
Two more categories could be read as cross-cutting, and the landscape post lists them that way. Here each sits on the rung where it does its damage. AI backend and database builders sit on Prompt to app, because a generated schema is where that rung's problems concentrate. Design to code sits on Agent in the editor, because its output lands in a codebase someone has to maintain.