The Hidden Content Generator: Why Every Function Generates Content from a Specification
Operations writes more content than marketing. HR writes more text than PR. Legal generates more documents than IR. AI’s substrate value is in spec-driven rendering across every function.
A COO at a professional-services firm told me recently that she had stopped attending the company’s AI working group. The group had now met fourteen times. Every agenda was the same: AI-generated marketing copy, social content, campaign personalization. She had left the previous meeting after thirty minutes.
Her team — operations, logistics, vendor management, quality assurance — produces somewhere between forty and eighty documents per week. Process specifications, work instructions, compliance checklists, vendor scorecards, RACI matrices, updated SOPs, training guides for new hires. None of it had appeared on any AI agenda. Her team was still writing every line by hand.
“Marketing produces one brief per week,” she said. “My team produces fifty. Who is this for?”
She was asking a structural question. The AI-content discourse is marketing-coded by default. Copilot for campaigns. Generators for social posts. AI that writes landing pages. The implicit assumption is that the content problem is a marketing problem — that the function generating the most text, with the most to gain from AI assistance, is the one managing the consumer interface.
This assumption is wrong by roughly an order of magnitude. Marketing generates a fraction of the total document output of any organization above a few hundred people. The majority lives in operations, HR, legal, engineering, and finance — and almost none of those functions have an AI roadmap that addresses it.
The opportunity is not where the spotlight is.
Where Corporate Content Actually Lives
The volume asymmetry is not close. Consider what each function actually produces over the course of a quarter.
Operations generates the highest volume of any function in most organizations. Every process that runs at scale requires documentation: standard operating procedures, work instructions, BPMN process flows, RACI matrices, ISO 9001 procedures, training materials for every new hire who needs to run the process, and an update cycle every time the process changes. Toyota Production System — the canonical benchmark for operationally excellent organizations — is built on the principle that the document is the process. Every kaizen cycle produces a revised work instruction. A mid-size manufacturing operation might maintain several hundred live SOPs at any given time, each requiring updates, version control, and distribution. None of that document infrastructure has historically had AI anywhere near it.
HR generates more text than most people realize because most of what HR does is communication: job descriptions rewritten for each posting, performance review frameworks, goal-setting templates, onboarding documentation, manager training content, policy documents, employee handbook updates, culture communications. Each hiring cycle in a growing company is a content production cycle. Netflix’s famous culture deck — the document Reed Hastings and Patty McCord wrote to make explicit what the talent management specification actually was — is the rare case where an HR specification was made public. Most organizations have the equivalent buried in internal wikis, half-outdated, written by whoever was in the HR function at the time.
Legal produces the most consequential per-document content of any function. Contracts, compliance documentation, IP filings, privacy policies, regulatory submissions, licensing agreements, NDAs, vendor terms, employee agreements. In any company navigating the current AI-IP legal environment — the New York Times v. OpenAI and Getty Images v. Stability AI cases are both still active as of 2026 — the legal function is producing a new class of document it did not produce three years ago. The irony is that legal is also the function most equipped, structurally, to benefit from spec-driven AI: legal documents are already heavily templated. They are already, in their structure, closer to a rendered specification than most documents in any other function.
Engineering produces API documentation, architecture decision records, technical specifications, runbooks, incident postmortems, onboarding guides for new engineers, and readme files at a rate that tracks closely with the velocity of the product. A company with a hundred engineers might maintain thousands of live technical documents. The documentation problem in engineering is so chronic that it has its own category in developer-satisfaction surveys. “Docs are always out of date” is a near-universal complaint in engineering organizations.
Finance generates financial reports, management accounts, investor decks, audit narratives, budget templates, board packs, and ad hoc analyses at a steady quarterly cadence plus a constant stream of one-off requests. The quarterly close cycle in a complex organization produces a remarkable volume of structured text — and almost none of it is generated from a formal specification. Each cycle, someone rebuilds the slide deck from scratch using last quarter’s version as a template.
Marketing, by comparison, produces one brief per week. One campaign per month. A handful of landing pages per quarter. Compared to the combined document output of operations, HR, legal, engineering, and finance, marketing’s content volume is small — and it is the function that has received the overwhelming majority of AI tooling investment.
The spotlight is on the wrong room.
Surface AI and Substrate AI
There is a structural reason the spotlight landed on marketing, and understanding it requires a distinction between two fundamentally different ways of using AI to generate content.
Surface AI works like this: take a prompt, produce an output, review the output, ship it. Generate a marketing email. Generate a job description. Generate a first draft of a contract. Each output is artisanal. Each review is independent. The quality of the output depends entirely on the quality of the prompt and the judgment of the person reviewing it. Nothing compounds. When you need the next output, you start again.
Surface AI is easy to deploy. The tools are consumer-friendly. The outputs are immediately visible and reviewable. It is genuinely useful — it saves time on the individual output. But it does not accumulate anything. Each generation is a transaction.
Substrate AI works differently. The starting point is a codified specification — a structured, versioned document that captures the essential facts of what the function does, what it commits to, what rules govern its outputs. A brand-spec YAML file. A competency-framework document. A clause library. An API contract. A financial reporting standard. Once the specification exists as a machine-readable artifact, AI can render it into any surface content the function needs — repeatedly, consistently, at scale — and the human’s job shifts from reviewing each individual output to iterating on the specification itself.
The shift is structural. Surface AI generates content. Substrate AI compounds substrate.
In Surface AI, the artifact that matters is the output. It decays quickly — it is reviewed, shipped, and replaced by the next output. In Substrate AI, the artifact that matters is the specification. It accumulates. Every time a team updates the spec, every future rendering benefits. The function shifts from artisanal production to systematic iteration.
This distinction explains why firms see wildly different ROI on AI deployment. The firms that see large returns have, often without naming it, invested in codifying their specifications before deploying AI to render from them. The firms that see modest returns have deployed Surface AI — high-quality outputs, no compounding. They are saving time one document at a time.
The misallocation is not about which AI tool to buy. It is about whether the function has a specification to render from.
Table 1: Each function’s spec and the surface content it generates. The Substrate-AI move is identical across all seven rows: codify the specification first, then AI renders surface content from it.
What Spec-Driven Generation Looks Like Per Function
The abstract distinction between substrate and surface becomes actionable when you trace it through each function specifically.
Marketing is the function that has come closest to this model, even if it has rarely named it. A brand-spec YAML that captures positioning, ideal recipient profile, voice characteristics, and dimensional emphasis gives AI something real to render from. Patagonia’s marketing team does not need to brief a copywriter from scratch for each campaign — they have a coherent underlying environmental-commitment specification that every piece of content can render from. The brief is short because the spec is real. Firms whose brief is long — thirty pages of brand guidelines that still produce inconsistent output — usually have a specification problem, not a brief problem.
Operations is the highest-leverage function for this shift, and the furthest from making it. Most operations teams have SOPs that are months or years out of date, BPMN diagrams that exist in Visio files nobody opens, and ISO 9001 procedures maintained as compliance artifacts rather than operational truth. The gap between the documented process and the live process is the spec debt. When that debt is paid — when the specification reflects what the function actually does — AI can generate updated work instructions, training content, and compliance documentation every time the process changes, rather than waiting for someone to find time to update the wiki. Toyota demonstrated that making the process specification the operational truth is what produces consistent quality at scale. The AI version of this is a live, versioned process spec from which all training and documentation content is continuously rendered.
HR has a clean version of the substrate problem. Most HR teams have a competency framework somewhere — often in a spreadsheet or a legacy system — that was written once, reviewed once, and has been applied inconsistently ever since. When a recruiter writes a job description, they approximate from memory what the competency framework says that role requires. When a manager runs a performance review, they approximate from memory what the evaluation criteria are. The result is that the firm’s talent management specification exists in principle but generates inconsistent surface content in practice. The Substrate-AI move for HR is to codify the competency framework as a versioned, machine-readable document and render every job description, every performance review template, and every onboarding guide from it. Netflix’s culture deck is the public-facing rendering of a real talent management specification. Most firms have the specification but have never rendered it consistently.
Legal is the function structurally closest to this model already. Contract templates are specifications. Clause libraries are specifications. Compliance checklists are specifications. The reason legal has not yet fully made the Substrate-AI transition is not a conceptual gap — it is a trust and review threshold. Legal review is conservative because the cost of a bad output is high. But the answer to that conservatism is not avoiding AI; it is investing in a better specification. A clause library that is comprehensive, up-to-date, and versioned gives AI something real to render from, and shifts the legal team’s review from “is this contract correct?” to “does this specification still reflect our risk posture?” — a fundamentally different and more leveraged question.
Engineering is perhaps the function where the substrate model has been most articulated, even if not under that name. The entire documentation-as-code movement — keeping API documentation alongside the API contract, auto-generating runbooks from infrastructure-as-code — is the same structural move. Stripe’s developer documentation is effective not because the writing is excellent but because the specification is real: the API contract is the truth, and the documentation renders from it. When the API changes, the documentation changes. The specification and the rendering move together because one is derived from the other.
Finance has the most structured specification of any function — GAAP, IFRS, and internal reporting standards are among the most codified rule systems in any organization — and paradoxically has some of the lowest AI adoption for document generation. Every quarterly report is built by hand from a template that is, structurally, a rendering of a specification. The financial reporting standard says what must be reported, in what format, under what conditions. AI that renders this specification into a draft quarterly report — with the human reviewing the financial facts and the spec-to-output accuracy rather than the prose — is not a speculative use case. It is an application of the same principle that already works in legal and engineering.
The Surface Operator and the Substrate Operator
The asymmetry between Surface AI and Substrate AI maps onto a structural problem that every organization already has with its human workforce.
An employee without access to a codified specification — without knowing what the firm actually commits to at each tier, without documented processes, without a real competency framework, without a clause library — will work from judgment, habit, and approximation. They will produce locally competent work and globally misaligned output. Not because they are a poor employee. Because the spec was never given to them. They are operating on a surface, with no substrate beneath their feet.
This is a pattern every management consultant recognizes: the new hire who does good work that does not fit, the senior employee whose decisions contradict each other over time, the team that produces high-quality outputs that all pull in slightly different directions. The diagnosis is almost always the same: the specification was not explicit, not codified, not cascaded down to the level where the work actually happens.
An AI without a codified specification does exactly the same thing. It generates locally competent output. It writes a professional job description. It drafts a plausible contract clause. It produces a coherent process instruction. Each output is fine in isolation. The collection of outputs drifts — because each was generated from a prompt rather than a specification. The human reviewer catches the individual errors but misses the cumulative drift, because the cumulative drift is invisible without a specification to compare against.
Surface AI = surface operator. Both are locally competent and globally misaligned. Both are producing outputs rather than compounding substrate. Both are expensive to manage, because every output requires independent review rather than a single verified specification.
The cure is symmetric. Codify the specification, cascade it through the organizational structure, render from it. For humans, this is what induction, onboarding, documented process, and coherent management philosophy are for. For AI, this is what a brand-spec YAML, a competency framework, a clause library, and a financial reporting standard are for. The firms that are excellent at deploying AI will also — not coincidentally — be the firms that are excellent at onboarding humans. The same underlying capability: the ability to make the specification explicit and render from it.
This is why AI ROI tracks spec-readiness rather than AI-spend. An organization that buys sophisticated AI tools and deploys them against an undocumented process will see modest returns. An organization that first documents the specification and then deploys even modest AI against it will see compounding returns. The AI is not the variable. The specification is the variable.
Where the Misallocation Lives
The current pattern of AI deployment in most organizations follows a predictable path: marketing gets the tools first, because AI copy generation is easy to demo and easy to approve. The output is immediately visible, the evaluation criteria are familiar, and the failure modes are low-stakes. A mediocre marketing email is a wasted impression, not a legal liability.
Operations gets the tools last, if at all. The output requires domain expertise to evaluate. The failure modes are higher-stakes: a wrong work instruction runs in production. The specification debt is higher: SOPs are old, BPMN diagrams are out of date, and the investment required to codify the specification before deploying AI seems large relative to the marketing-copy use case where the spec is implicitly just “sound like the brand.”
HR occupies a middle position: AI job description generators are now widely used, but competency-framework codification — the substrate move — almost never accompanies them. The result is that HR teams generate more job descriptions faster, but those job descriptions still reflect inconsistent views of what the roles require, because the competency framework was never actually codified. Surface AI with no substrate beneath it.
Legal is beginning to make the move in the direction of substrate, driven by the AI-IP exposure: firms that have invested in documenting their IP posture and building out clause libraries are finding that AI generates contract drafts that require less review. But most legal teams are still in the surface phase: AI that assists with contract review is not the same as AI that renders from a real specification.
The misallocation pattern has a logic to it: AI is deployed where it is easiest to deploy, not where it accumulates the most substrate. Marketing copy is easy to deploy against, even without a real brand specification, because the output evaluation is subjective. Operations documentation is hard to deploy against without a specification, because the output evaluation is objective — the work instruction is either right or wrong — and building the specification first takes organizational effort that no AI vendor demo includes.
The opportunity is inverted relative to where the investment is going.
Three First Moves
Most organizations have never audited their specifications across functions. The three moves that follow are listed in the order that produces the fastest compounding, not the order of least resistance.
Inventory your specs. For each function — marketing, operations, HR, legal, engineering, finance — ask: what is the codified, versioned specification that AI could render from? Marketing usually has the best (brand guidelines, at minimum). Operations often has the worst (SOPs that are stale, BPMN diagrams that no one updates). HR sits in between (competency frameworks exist somewhere, usually in a form that is not machine-readable). Legal varies by organization size and industry. Engineering is often surprisingly good in companies that have adopted infrastructure-as-code practices. Finance is typically strong on standards but weak on making those standards available in a form AI can render from.
The inventory will reveal where the spec debt lives. That is the roadmap.
Reallocate AI deployment toward the lowest-spec functions first. This is counter-intuitive. The natural tendency is to deploy AI where it is easiest — marketing copy — and delay the harder work of specification codification in operations and HR. Reverse this priority. Surface AI without a spec generates muda: locally plausible outputs that do not compound. Substrate AI with a real spec compounds with every iteration. A single investment in codifying the operations spec — documenting the actual process, versioning it, making it machine-readable — produces compounding returns every time the process is rendered into training content, work instructions, or compliance documentation. The same investment in marketing, where the spec is often already implicit in the brand guidelines, produces lower marginal returns because the spec debt is lower.
Treat the spec as the asset, not the output. This is the hardest shift to make organizationally, because output has always been the visible deliverable. The job description is visible. The process document is visible. The contract clause is visible. The competency framework that all of them render from is invisible — it exists in a document that no one reads unless they have to. The Substrate-AI transition requires inverting this: the spec is the asset, the output is temporary. Version the spec. Review changes to the spec carefully. Invest in making the spec comprehensive and accurate. The outputs will follow — and they will follow consistently, because they have something real to render from.
GitLab’s 4,500-page public operations handbook is the extreme version of this. The handbook is the specification. Every process, every decision-right, every hiring criterion, every expectation of behavior is documented, versioned, and publicly available. The organization renders from the spec rather than from tribal knowledge. Onboarding a new employee is the same structural operation as prompting AI to generate a new work instruction: both start from the specification, both render the output from it. The quality of the output tracks the quality of the spec.
The Rendering Engine
The AI-content discourse is about marketing copy because marketing copy is where AI tools were first deployed at scale. But marketing copy is a small fraction of the content an organization generates, and it is not the fraction where the compounding happens.
AI is a rendering engine. It renders specifications into surface content. The question is whether you have a specification to render from. For most functions, the answer is currently: partially, implicitly, inconsistently.
The functions that will compound substrate fastest will be the functions that codify their specifications first — and most of them are not marketing. Operations generates fifty documents for every brief the marketing team produces. HR generates job descriptions, performance reviews, and training guides at a rate that tracks headcount growth. Legal generates contracts, compliance documentation, and IP filings at a rate that tracks business complexity. Engineering generates API documentation and runbooks at a rate that tracks product velocity.
When each of those functions has a real specification — versioned, machine-readable, reviewed and updated by the people who govern that function — AI generates consistent, aligned content from it. The humans iterate on the spec. The AI renders from it. The spec compounds. The surface decays.
The COO who stopped going to the AI working group was not asking the wrong question. She was asking the right question in the wrong room. The AI content problem her team has is not a tool problem. It is a specification problem. And the specification problem is fixable — which means the AI problem is too.
Read the full paper on Zenodo: doi.org/10.5281/zenodo.19064426
The six-tier organizational architecture that underlies this piece: doi.org/10.5281/zenodo.19895813
Part of the Multi-Interface Specification Series: Brand Is One Interface · Marketing Is the Push, Demand Is the Pull