The Inversion
I.
If you walk through a modern office after sunset, the light reflecting off the glass walls is almost always green. Not the green of a terminal or a trading floor, but the muted grid of a spreadsheet. Formulas reference other formulas across dozens of tabs. Cells contain logic that took years to accumulate and minutes to break.
These workbooks are the quiet engines of the modern economy. In regulated industries, they are not documents but systems. They calculate tax positions, model risk exposure, allocate capital, and justify decisions that carry material consequences.
For a long time, artificial intelligence could not touch them. Not because the models lacked capability, but because a spreadsheet is not a document. It is a network of dependencies. Meaning lives in the relationships between cells, not in any sequence of words. Feed it to a model as text and the model sees numbers. The thousands of logical gates that connect input to output remain dark matter: present, consequential, invisible.
At PwC, the shift came when we stopped asking models to read spreadsheets and started teaching them to navigate structure. Decompose the workbook into regions. Map the dependencies between formulas. Let the system traverse the file as a graph rather than a page. It no longer needed to hold everything at once. It needed only to find the logic relevant to the question being asked.
What changed was not the spreadsheet but the representation. What had been a static artifact became something that could be queried. Logic that had been locked inside manual processes could now be inspected, tested, and reasoned about by a machine. The first inversion is the oldest: making hidden logic visible.
The data had always been there. We just couldn't see it until we changed how we looked.
II.
In the early phase of the current transition, the craft was in the instruction. Teams wrote prompts, assembled agent specifications, versioned them, debated their phrasing. The quality of the output depended on the precision of the input, so precision became the work.
This was not misguided. At that stage, small changes in wording produced material differences in outcome. The prompt functioned as code. It was the interface between what a person intended and what a machine produced.
Then the models improved. They became better at inferring context, resolving ambiguity, filling in what was left unsaid. The careful scaffolding of the prompt began to matter less. What once required elaborate instruction increasingly required only a clear statement of purpose. The mechanics of the interface receded from view, the way the details of network protocols disappeared once the web became usable without understanding how packets moved.
The instruction layer is compressing into the model itself. Prompts and code, once treated as durable artifacts, are increasingly the exhaust of the process, generated to fulfill a goal, discarded once it is achieved. The second inversion is quieter: the compression of instruction into capability.
The things we labored over most are becoming the things that matter least. The craft was real. The layer was temporary.
III.
There was a time when the bottleneck was access to code. Then it was access to infrastructure. Both constraints eased. What remains is upstream of either.
If machines can traverse our data and generate the instructions to act upon it, the limiting factor is no longer execution. It is knowing what to execute and why.
We tend to assume that intent is set at the start of a project. Requirements are gathered, specifications are written, and building begins. In practice, intent is not a starting condition. It is an emergent property. It surfaces through friction: through the encounter between what was specified and what was actually needed. Edge cases appear. Assumptions that felt solid dissolve on contact with use. The act of building has always been inseparable from the act of discovering what was really meant.
When building is slow, that discovery hides inside the cost of delivery. When building is fast, the discovery is the work. The third inversion is the most uncomfortable: the exposure of intent.
What we have treated as secondary artifacts, prompt iterations, design rationale, the trail of revised specifications, are records of that discovery. They document the moment an assumption became a question and a question became a constraint. They are evolutionary maps of how thinking actually developed, as opposed to how we later claimed it did. Without them, each project begins from the same starting assumptions. With them, the next project begins where the last one's understanding ended.
For decades, organizations rewarded execution because execution was scarce. As that scarcity ends, what remains scarce is the clarity to describe it.
The spreadsheet era taught us to preserve logic in cells. The software era taught us to preserve logic in code. This era may require us to preserve the logic of our own thinking: how objectives evolved, where assumptions broke, and why decisions were made.
That is not documentation. It is infrastructure for judgment.