From Consumer-Generated Content to Consumer-Generated Companies

Content → code → company.

This arc is not three separate markets. The same mechanism is being applied to larger units of work. A person states intent. A model turns it into an artifact. A platform distributes the artifact. The first artifact was a post, review, video, or song. The second was a function, pull request, or application. The third is an operating company: a bundle of workflows, responsibilities, tools, memory, payments, support, and distribution that can run without every decision passing through a traditional org chart.

I call this consumer-generated companies. The phrase sounds strange because company formation still carries the language of institutions: incorporation, departments, process owners, managers, budgets. But the primitive underneath has changed. The unit a non-specialist can now generate is no longer only content. It is no longer only code. It is the operating surface of a business.

human intent
   ↓
foundation model
   ↓
artifact gets larger each decade
   ↓
content        code             company
post/review → function/app → workflow/business unit
   ↓             ↓                ↓
feeds         repos            logged workflows

Stage one: consumer-generated content

Consumer-generated content won because it lowered the cost of expression and raised the trust of the artifact. A product review from a stranger often felt more useful than a brand message. A Wikipedia page often beat a brochure because it could be corrected in public. A YouTube video from a user could show the thing working, failing, or being used in a context a company would never script. Yelp, TikTok, Reddit, Amazon reviews, and creator platforms all inherited the same pattern.

The economics were simple. The user did the creative labor. The platform owned the substrate: identity, hosting, ranking, moderation, distribution, and monetization. The user got reach. The platform captured the market structure.

The important business lesson from UGC is not that people like authenticity. They do, but that preference sits downstream. The stronger lesson is that the substrate wins. The company that gives millions of users a reliable way to create, publish, rank, and monetize captures more value than any single creator.

The market data is blunt. Fortune Business Insights estimates the user-generated content platform market at $7.1 billion in 2025 and $64.31 billion by 2034. Grand View Research estimates the broader creator economy at $205.25 billion in 2024 and $1.345 trillion by 2033. Bazaarvoice frames creator marketing around brand trust, shopper behavior, and the operating systems brands use to harvest creator output. Yotpo points to TikTok Shop as a direct example of content collapsing into commerce, citing eMarketer’s estimate that it accounted for nearly 20% of U.S. social commerce sales in 2025.

The through-line is not media. It is infrastructure for turning intent into distributable artifacts. Wikipedia did it for knowledge. YouTube did it for video. TikTok did it for short-form entertainment and commerce. Bazaarvoice and Yotpo did it for reviews, creator assets, and brand-controlled syndication. The winning companies did not need to write every artifact. They made artifact creation cheap, legible, and monetizable.

Stage two: consumer-generated code

LLM code generation moved the same pattern one layer deeper. A non-specialist or semi-specialist can describe behavior in natural language and get a working software artifact: a script, test, UI, API route, migration, or pull request. The gatekeeper removed is not all engineering judgment. It is the requirement that every unit of software begin as hand-authored syntax.

GitHub describes AI code generation as software that turns natural-language prompts into code and supports completions, tests, documentation, and explanation across the development workflow. Its more technical overview explains how these systems map user intent, context, and examples into code suggestions. Google Cloud describes the same shift around Gemini Code Assist and code generation use cases. The interface changed from writing every token to supervising a model that proposes the next artifact.

The adoption curve is already mainstream enough to stop treating codegen as a demo. Stack Overflow’s 2025 Developer Survey reports that 84% of respondents use or plan to use AI tools in development, and 51% of professional developers use them daily. GitHub now gives enterprises Copilot metrics for adoption, engagement, acceptance rate, lines of code, and pull request lifecycle, which means AI-assisted code has moved from toy to managed delivery surface. Code generation has become a measurable workflow, not a side conversation.

The skeptic is also right. The code is often wrong. Stack Overflow reports weak trust in AI output, with more developers distrusting accuracy than trusting it, and names the top frustration as answers that are almost right but not quite. METR’s 2025 randomized study found that experienced open-source developers working on familiar, large repositories were 19% slower with early-2025 AI tools, even though they believed the tools made them faster.

That objection matters, but it does not break the pattern. Early user-generated content was messy too. Wikipedia was not trusted by default. YouTube was full of low-quality uploads. Reviews were gamed. Spam followed every cheap publishing surface. Quality came later through ranking, moderation, identity, reputation, creator tooling, and economic incentives.

The same is happening with code. The bottleneck is shifting from generation to review, tests, provenance, security, and ownership. The question is not whether a model can emit a function. It can. The question is whether the workflow can prove the function belongs in the system.

Stage three: consumer-generated companies

The next artifact is the company itself.

That does not mean a prompt creates legal personhood, removes liability, or replaces operators. It means the operating pieces of a company are becoming generable and composable: market research, offer design, landing pages, CRM records, outbound drafts, support workflows, procurement checks, billing, reconciliation, compliance evidence, dashboards, and escalation paths.

BCG’s AI-first consumer products work gives the enterprise version of this shift. It says about 20% of decisions in the typical consumer path are influenced by large language models, and that AI agents are changing how consumers discover, evaluate, and purchase products. It estimates AI can create 500 to 800 basis points of financial value for consumer products companies, with more than 90% of initial value coming from reshaping workflows before inventing new business models.

The agentic commerce evidence is even more direct. OpenAI launched Instant Checkout in ChatGPT with the Agentic Commerce Protocol, built with Stripe, so users can discover and buy from merchants inside the chat surface. Stripe describes the protocol as a shared language between businesses and AI agents, with Shared Payment Tokens scoped to a merchant and cart total so an agent can initiate payment without seeing raw credentials. BCG’s agentic commerce work argues that retailers may need to make themselves discoverable to third-party agents and build their own brand agents. McKinsey names the emerging technical stack explicitly: MCP, A2A, AP2, and ACP as protocols for autonomous agents, payments, and commerce.

At this point the metaphor becomes operational. If an agent can search, compare, buy, open tickets, update records, call tools, deploy code, and hand work to humans with state attached, the artifact is no longer just the software. It is a running business process.

The gatekeeper removed is the org chart. Not accountability. Not law. Not taste. Not judgment. The org chart as the only way to coordinate specialized labor.

The common engine

All three stages use the same loop:

intent → model → artifact → distribution

Only the artifact changes size.

A tweet is a small artifact. A pull request is larger. A business unit is larger still because it contains state, commitments, money, customer promises, exceptions, and humans. That is why consumer-generated companies need a different infrastructure standard than consumer-generated content or consumer-generated code.

The hard part is not generation anymore. The hard part is durability.

A company cannot run on a chat transcript. It needs persistent state. It needs idempotent workflows. It needs audit trails. It needs secrets management. It needs permissions. It needs owners. It needs a way to pause when confidence is low and hand the decision to a human with context attached. It needs to remember what it promised and prove what it did.

The current agent stack stops being abstract when it touches the workbench. Slack and Linear are good human interfaces because people already live there and because decisions can be threaded, assigned, and reviewed. Durable execution systems like Temporal and Restate matter because company workflows have to survive retries, timeouts, and partial failure. MCP matters because it gives AI systems a standard way to connect to tools, data, and workflows. Doppler or an equivalent secrets layer matters because agents should not paste credentials into prompts. Render, containers, and CI matter because generated software still has to deploy into a real runtime. Stripe-style agentic payment primitives matter because commerce needs scoped authority, identity, risk controls, refunds, and customer support.

MCP’s own documentation calls it an open-source standard for connecting AI applications to external systems: data sources, tools, and workflows. Think of that as a USB-C port for AI apps. Consumer-generated companies need ports, not magic. A company is a network of tools with memory and obligations.

A worked example: de novo as an operating artifact

Imagine a domain expert wants to create a de novo home-services company for a neglected local niche: emergency sump pump monitoring for small multifamily buildings.

In the old pattern, that person needs a technical cofounder, a designer, a marketer, an operations lead, a finance person, a support process, vendor relationships, and months of coordination before the company can test demand.

In the consumer-generated company pattern, the first artifact is a running operating loop.

The founder states the intent in Slack: “Test whether small landlords will pay for 24/7 sump pump monitoring with same-day technician dispatch. Keep the first market to 50 buildings. Do not buy hardware until we have paid pilots.”

An agent turns that into a Linear project with milestones: offer, lead list, landing page, customer interview script, monitoring workflow, technician dispatch path, billing setup, risk register, and go/no-go criteria. Another agent builds the landing page and deploys it on Render in a container. A CRM workflow creates owner-first lead records and marks each claim with source evidence. A payment workflow creates a Stripe test product but requires human approval before live charges. Doppler stores the API keys. MCP servers expose the CRM, calendar, email draft surface, deployment logs, and support queue as tools. A durable execution layer runs the outreach and onboarding workflows so a retry does not double-send an email or double-create a customer account.

The company has not become autonomous. It has become inspectable.

Every promise has state. Every handoff has an owner. Every external action has a log. Low-confidence steps stop for review. A landlord objection becomes a tagged research note. A technician no-show becomes an escalation path. A failed payment becomes a support task, not a lost chat message. The founder is still accountable, but the founder is no longer the private memory that holds the business together.

Hadto cares about this de novo primitive: an operating company that can be generated, inspected, taught, and improved by domain experts who would otherwise never get the technical substrate. The target is not a fake autonomous CEO. The target is a company a real owner can govern.

Objections that should stay in the design

Liability does not disappear. If an agent-run workflow harms a customer, violates a regulation, misrepresents a product, or mishandles money, someone is responsible. Consumer-generated companies need legal owners, insurance, compliance review, and kill switches.

Quality collapse is a real risk. UGC created spam farms and review fraud. Codegen creates plausible bugs and security issues. Company generation can create low-quality businesses that flood channels with synthetic offers, shallow support, and fake differentiation. The answer is not to pretend this risk is small. The answer is to build provenance, reputation, review, and capital discipline into the substrate.

Regulators will not accept “the agent did it” as an answer. Payments, employment, lending, health, insurance, and professional services all have personhood and accountability assumptions. The more company-shaped the artifact becomes, the more the stack needs identity, authorization, auditability, and human signoff.

The strongest version of consumer-generated companies is not founderless. It is founder-amplified and workflow-bound. The operator supplies intent, taste, constraints, and accountability. The system supplies the repeatable machinery.

The builder question

Consumer-generated content created enormous markets because platforms made expression cheap and distribution immediate. Consumer-generated code is changing software because models made implementation conversational and review measurable. Consumer-generated companies are the next step because the same intent engine is reaching operations, commerce, support, procurement, and governance.

The question is not whether a prompt can create a company. A prompt cannot.

The question is whether we can build the substrate where a domain expert’s intent becomes a set of logged workflows: state, permissions, payments, evidence, escalation, and deployable software attached.

The creator economy was built by giving people a publish button. The next economy will be built by giving them an operating button. Build that button with logs, owners, and brakes.