Programming After the Price Shock
How LLMs Change Programming, Enterprise Organisation and the Structure of Capital
The usual account of large language models begins with the programmer and asks how much faster code can be written. It counts functions produced, tests repaired, tickets closed, languages translated. These gains are real, but they are local. They describe what happens when a cheaper instrument is inserted into an existing method of production; they do not ask whether that method remains rational once the price of one of its principal inputs has changed.
That is the larger question.
An enterprise is a structure of production. It combines people, machines, software, contracts, information, routines and time in order to reach ends which lie beyond the immediate act. When relative prices change sharply, the best combination changes with them. The old arrangement may continue to work. It may even look efficient according to the measures built around it. Yet it can still have become economically obsolete.
Large language models are such a price change.
They have lowered the cost of producing candidate symbolic structures: code, schemas, translations, interfaces, explanations, test cases, queries, classifications, plans. They have lowered the cost of entering unfamiliar systems and moving between representations which previously required a specialist at every boundary.
They have not lowered all relevant costs equally.
The cost of producing a plausible answer has fallen much further than the cost of establishing that it is true. The cost of generating code has fallen further than the cost of proving that it captures the intended behaviour. The cost of drafting a policy has fallen further than the cost of knowing whether it will survive contact with law, incentives, customers and adverse cases.
This asymmetry governs everything that follows.
Candidate structures are becoming cheap. Reliable judgment, disciplined verification, contact with the world and responsibility for irreversible decisions remain scarce. The rational enterprise must reorganise itself around that new relation between abundance and scarcity.
I. Capital after the fall in symbolic prices
Austrian capital theory begins by refusing to treat capital as a homogeneous fund.
A machine, a warehouse, a railway siding, a data model, a compiler, a test harness and an experienced operator are all capital goods, but their value depends upon the plans into which they enter. They complement some goods and obstruct others. They are not valuable because labour has been spent upon them; they are valuable because they enlarge the range of future actions which can be carried through successfully.
Software belongs squarely within this account.
A schema is a capital good. So is an API, a build system, a migration tool, a collection of production traces, a code generator, an ontology, a body of examples, a carefully designed type system. Their importance lies not only in what they do now, but in what they make possible later. A brittle schema may support today’s report while making tomorrow’s product ruinously expensive. A test corpus may appear unproductive until it permits an entire class of changes to be made safely.
Lachmann’s emphasis on capital heterogeneity is particularly useful here. Capital goods are not merely accumulated; they are combined, revised, abandoned and recombined as plans change. LLMs matter because they alter the cost of creating and rearranging a large class of intellectual capital goods.
Before them, many such goods were uneconomic.
A firm might know that it needed a parser for an old format, a migration layer, a semantic map of an inherited codebase, a replay system for historical behaviour, an adapter around a difficult library. Yet each required weeks or months of scarce programming labour, and its benefit was dispersed across future work. The firm therefore tolerated opaque interfaces, manual reconciliations, old languages and regions of code which nobody wished to disturb.
Those choices may once have been rational. They are not sanctified by age.
Once symbolic transformation becomes cheaper, the inherited capital stock must be repriced. The relevant question is no longer what it cost to understand, wrap, translate or replace a system when the original decision was made. The question is what it costs now, and which combinations have become possible that were previously closed.
Enterprises often confuse historical expenditure, institutional familiarity and economic value. A system may be called critical because every process has bent itself around its limitations. A workflow may appear indispensable because an entire department exists to reconcile it with another workflow. A piece of software may survive because its defects have accumulated complementary labour.
LLMs expose this distortion. They make comprehension cheaper, translation cheaper, local tooling cheaper. A system which once had to be preserved because nobody could safely traverse it may now be mapped, characterised and enclosed behind a new interface. A family of manual reconciliations may now justify a custom intermediate system. A legacy library may be wrapped, then displaced gradually from the edges inward.
Yet restraint is still necessary.
The difficulty of an old system often lies only partly in its code. It may embody years of regulatory accommodation, customer promises, departmental compromise and historical exceptions. The code is obscure because the institution is obscure.
LLMs reduce code-comprehension debt much more readily than institutional-embedding debt.
That distinction should govern legacy strategy. Firms should be bolder where the principal obstacle was the historical price of symbolic labour, more cautious where the software is the visible surface of a negotiated settlement among people, rules and expectations. Rewriting code is becoming cheap. Rewriting institutions is not.
II. Roundaboutness on a smaller scale
Böhm-Bawerk’s account of roundabout production is often reduced to the proposition that one waits longer in order to obtain more later. Its deeper significance lies in the use of produced means of production. One does not continue to perform the final act directly; one first builds tools, machines and intermediate goods which alter the productivity of every subsequent act.
LLMs lower the cost of producing such intermediate intellectual goods.
A programmer faced with an unfamiliar codebase can now construct a map, a query tool, a set of invariants, a source transformation, a synthetic corpus or a differential test harness before touching the final change. A domain specialist can turn a body of rules into an executable model before commissioning a full system. A team can build an internal language, an adapter or a diagnostic instrument for a problem which would previously have been managed by convention and memory.
The method becomes more indirect. It passes through more machinery.
Yet it may finish sooner.
This is the central paradox of LLM-era programming. Production can become more roundabout in structure while becoming faster in calendar time. The longer path becomes the quicker path because the cost of building the intermediate means has fallen.
A programmer who writes the final patch immediately may now be less efficient than one who first produces characterisation tests, maps the subsystem, compares several transformations, then submits the smallest verified change. Under the old price structure, this might have been excessive engineering. Under the new one, it may be ordinary prudence.
The same logic extends beyond programming.
Many enterprises are filled with work which exists because durable formalisation was too expensive. People copy values between systems. Specialists translate business requests into technical specifications, then technical results back into managerial language. Meetings preserve context which no system represents. Documents stabilise decisions which would otherwise disappear into memory.
Some of this is irreducible. Much of it is compensation for machinery that was never built.
As the price of building that machinery falls, the enterprise should become more roundabout technically and less roundabout administratively. It should contain more semantic adapters, executable checks, local tools, explicit representations and automated feedback. It should contain fewer chains of human translation.
This separates capital deepening from bureaucracy.
A parser, a schema, a replay environment or a verification harness is an intermediate good which raises the productivity of later work. A five-stage approval chain may merely reflect the fact that nobody can see the system clearly enough to trust a change. Both stand between intention and result; only one necessarily increases productive power.
The danger is that firms will preserve the second while adding the first. Every department will receive an assistant. Every stage will produce reports, plans, tickets and reviews more quickly. The volume of internal material will rise, while the structure of coordination remains untouched.
Local productivity will improve. Total throughput may not.
A firm can reduce the price of its own confusion.
III. From code production to verified transformation
The old programming economy treated code as scarce.
It therefore organised teams around producing code. Specifications were prepared so that expensive developers would not waste effort. Work was divided into specialist queues. Testing was compressed because implementation had already consumed the schedule. Documentation was deferred because writing it required the same people needed elsewhere.
Once candidate code becomes cheap, this ordering loses its logic.
The scarce object is no longer implementation alone. It is the verified transformation: a change for which the intended behaviour is clear, the consequences are bounded, the relevant evidence has been gathered and the remaining uncertainty is understood.
This moves the centre of gravity from production to reality-contact.
A good test is not merely an assertion written after the code. It is a compact statement about what the world permits. A production trace is not debugging residue. It is evidence about the behaviour of the living system. A schema is not administrative documentation. It is a constraint upon what may be said and done. Provenance is not clerical overhead. It is the path by which a claim can be traced back to its source.
These become first-class capital goods because they discipline an abundant generator.
An enterprise which gives an LLM access to a large codebase but no stable semantic structure will obtain fluency without dependable direction. One which exposes types, interfaces, invariants, examples, traces, dependencies and reproducible environments obtains something more valuable: a system in which candidate changes can be produced quickly and rejected cheaply.
The second capability matters more.
The human role changes with it. A domain expert is no longer most valuable when manually converting every rule into prose for a programmer. The expert is most valuable when identifying decisive distinctions, adverse cases, exceptions and evidence. The senior engineer is no longer most valuable because he remembers obscure syntax. He is valuable because he knows which assumptions will fail, which abstractions will survive, where the system touches irreversible reality and what experiment could settle a disputed design.
Judgment rises in value when production becomes cheap.
So does the design of verification.
The rational enterprise should spend less on manually producing symbolic artefacts and more on constructing environments in which false artefacts reveal themselves. That means replay systems, simulation, differential testing, property testing, shadow execution, provenance, audit trails, reproducible builds and explicit operational constraints.
It also means resisting a familiar mistake. More tests are not necessarily more verification. A model can generate thousands of tests which reproduce its own misunderstanding. The quality of an oracle matters more than the quantity of assertions. The system must be connected to evidence which did not arise from the same act of generation.
This is where Hayek’s problem of knowledge reappears. LLMs make articulated knowledge easier to transmit and recombine, but they do not abolish tacit knowledge, local circumstance or dispersed judgment. They can even make the articulated representation so persuasive that it displaces the competence from which it was abstracted.
The enterprise must therefore formalise aggressively without pretending that whatever has been formalised is the whole of reality.
IV. The boundary of the firm begins to move
The structure of the enterprise reflects the costs of communication, coordination and specialisation. When it is expensive for one person to understand several domains, work divides. When internal software is expensive, firms buy general products and adapt themselves to the products’ categories. When experimentation requires a full project team, investment concentrates in a small number of large programmes.
LLMs disturb all three conditions.
A small team can now traverse a longer portion of the production chain. It can investigate a domain, model the data, construct the interface, implement the system, build the tests and observe the result. This does not abolish specialisation. It moves specialisation upward.
The scarce specialist is less often the person who alone knows a syntax or local procedure. It is the person whose judgment rests upon deep experience, privileged access to reality or responsibility for consequences.
The rational unit of organisation therefore becomes the closed loop.
A team should own a problem from observation to intervention to measured result. Where the loop is divided among departments, each department optimises its visible output. Analysts produce analyses, developers produce features, testers produce defects, operations preserves stability. Nobody necessarily owns the truth of the sequence.
LLMs make that fragmentation less defensible because the cost of crossing boundaries has fallen. A good team can absorb more adjacent competence. Agents can perform much of the translation which once justified separate queues.
The same change affects the make-or-buy boundary.
For decades, firms were told to buy standard software unless the capability differentiated them. The advice rested upon high fixed costs of internal development. As those costs fall, small bespoke systems become rational. A custom reconciliation tool, a narrow workflow engine, a local reporting language, a specialised operations console or a set of adapters around an existing platform may cost less than bending the organisation around a generic product.
This does not imply a return to vast internal software departments. It points toward many small, replaceable, purpose-built capital goods.
They should be built with caution. Models will improve. Today’s orchestration may become tomorrow’s curiosity. Durable investment should concentrate where the asset remains useful across model generations: schemas, interfaces, corpora, traces, ontologies, provenance, evaluation systems, permissions and stable access to underlying data.
A framework designed around the transient weaknesses of one model is perishable capital.
A structured representation of the enterprise is not.
Architecture should follow the same rule. LLMs do not necessarily favour the smallest services or the greatest fragmentation. Many microservice estates were responses to organisational boundaries rather than technical necessity. If a small team can understand a larger coherent system, a modular monolith may be more legible than hundreds of simple services whose behaviour emerges only at runtime.
The decisive property is not smallness. It is discoverability.
The system should make causes, constraints and consequences visible. It should allow a human or agent to ask what depends upon a change, which assumptions are violated, what evidence supports a claim and how the prior state can be reconstructed.
Architecture becomes less a matter of arranging boxes and more a matter of preserving legibility under change.
V. Planning, calculation and malinvestment
The enterprise project is an artefact of high setup costs.
When it takes months to assemble a team, specify a system and produce a first result, management is driven toward large ex ante commitments. Business cases become elaborate because the decision cannot easily be reversed. Requirements are frozen because each change threatens the schedule. Political effort concentrates around securing the initial allocation.
LLMs lower the cost of making an idea concrete.
A hypothesis can become a prototype, simulation, internal tool or executable model before the firm has agreed to fund a programme. Several architectures can be tried rather than debated. Historical data can be replayed through competing approaches. A narrow market can be tested without first proving that it supports a permanent team.
This changes the economics of planning.
The rational firm should move from project selection toward staged commitment. It should create more options, spend less on each initial option, bind each to evidence, then increase investment only where the evidence strengthens.
This is not a celebration of experimentation for its own sake. Cheap experiments can become another form of waste. The important change is that uncertainty can be purchased down in smaller increments.
The firm should ask earlier questions of reality and later questions of permanence.
Kirzner’s account of entrepreneurial discovery matters here. The future is not a known distribution waiting to be optimised. Many relevant facts do not yet exist. They will be discovered only through action. LLMs reduce the cost of those actions which take symbolic and computational form.
Yet they also make self-deception cheaper.
A team can now generate a convincing market analysis, a polished prototype, a coherent technical design and a full implementation before encountering a single customer who cares. An internally persuasive plan can accumulate with extraordinary speed. The quantity of apparent evidence rises while the amount of independent evidence remains unchanged.
This is the characteristic malinvestment of symbolic abundance.
The firm mistakes internally generated coherence for economic information.
Mises’s problem of economic calculation therefore becomes more acute inside the enterprise. LLMs can produce more proposals, forecasts and justifications than management can properly evaluate. They do not supply the market prices which reveal whether an internal project is the best use of scarce resources. They may instead thicken the fog around that question.
The firm needs stronger mechanisms of selection precisely because technical production has become easier. Kill criteria, customer behaviour, opportunity cost, internal transfer prices, measured risk reduction, external revenue and genuine usage matter more when every proposal can arrive dressed as a finished argument.
The question is no longer whether a team can build the thing.
It is whether building it is the best use of attention, institutional capacity and time.
VI. Where practice should change first
The largest gains will not come from distributing chat interfaces evenly across the organisation. They will come from changing those parts of the production structure whose shape was determined by the old price of symbolic labour.
Coordination should move away from inert documents wherever knowledge can become schemas, examples, tests, simulations, queries and executable constraints. Prose remains necessary, but it should no longer bear alone the burden of preserving institutional knowledge.
Integration should receive much more attention. Enterprises contain enormous latent value behind awkward boundaries: old databases, incompatible formats, duplicated categories, brittle vendor systems, manual reconciliations. This work was neglected because it was detailed, local and difficult to justify as a grand programme. LLMs make precisely this class of intermediate engineering cheaper.
Verification should become a principal object of capital expenditure. Every organisation should ask what its trusted oracles are. Which traces, datasets, invariants, simulations and external observations allow it to distinguish a working system from a plausible imitation? Where these do not exist, building them may have a higher return than building the next feature.
Teams should be reorganised around loops which join diagnosis, implementation and feedback. Where six functions own six stages, the enterprise should test whether a smaller group, aided by agents, can own the whole result. The aim is not flattening for its own sake. It is the removal of boundaries whose principal justification was the former cost of translation.
Capital allocation should become more sequential. More alternatives can be explored; fewer should be made permanent. Investment should increase with evidence rather than with the persuasive force of the initial narrative.
These changes reinforce one another.
Executable coordination makes systems legible. Legibility makes integration safer. Integration enlarges the domain a small team can command. Small teams shorten feedback loops. Short feedback loops make staged investment possible. Staged investment lowers the cost of being wrong.
That is the compounding structure.
VII. The new discipline
The deepest difficulty is that LLMs make the accumulation of symbolic artefacts look like capital formation.
It may be the opposite.
A codebase can grow while the enterprise’s future freedom shrinks. A knowledge system can expand while its contact with reality weakens. A workflow can become more automated while the institution loses the people who understood why the exceptions existed. A firm can acquire more machinery and become less capable of changing direction.
The old world had a crude defence against this. Symbolic production was expensive. Many bad ideas died because nobody could afford to implement them.
That defence is disappearing.
The new discipline must be conscious. Enterprises will have to distinguish machinery which enlarges future possibility from machinery which merely elaborates the present plan. They will have to distinguish semantic capital from symbolic debris, verification from repetition, optionality from unfinished commitment, abstraction from distance.
The winning firm will not be the one which generates the most code, automates the most tasks or gives the most employees access to an agent.
It will be the one which understands where the price has actually moved.
It will use cheap symbolic production to build instruments, intermediate representations and local machines. It will reserve expensive human attention for judgment, conflict, responsibility and the interpretation of evidence. It will deepen its technical capital while reducing the administrative structures which once compensated for the absence of such capital. It will experiment more widely and commit more selectively. It will rewrite some systems boldly and leave others alone because it understands that code and institution are not the same object.
Programming will become more important because more of the enterprise can now be made explicit, executable and revisable.
But programming will no longer mean chiefly the manual production of code.
It will mean the design of systems in which conjecture is cheap, constraint is visible, error is discoverable and capital can be rearranged before the institution mistakes its own machinery for reality.