The career that was supposed to die is the career best positioned to reshape the world.

Programmers adopted AI tools faster than any technology in history. Not because they were told to — because the tools were genuinely incredible. ChatGPT, Claude, Copilot. Code that took a day takes an hour. Boilerplate disappears. Entire functions materialize from a sentence.

Within months, teams divided. The ones using AI were measurably faster. The ones who refused fell behind. Management didn't need metrics to see it. The gap was obvious. And management acted on it.

Microsoft laid off 6,000 people — 40% of them software engineers. Klarna eliminated 38% of its headcount. IBM cut 8,000 roles. Dell cut 12,500. In each case, AI was cited.

CS enrollment fell 8.1% — the largest decline of any college major in the country. Twenty-eight percent of graduating CS students describe themselves as "very pessimistic" about their careers.

These numbers have an address. They live in the house of the developer who just got the "we're restructuring" email. In the apartment of the CS grad with $80,000 in student debt and no callbacks. In the kitchen where someone is explaining to their spouse that the industry they spent twelve years building a career in is contracting by a quarter.

The uncomfortable truth is that the people getting let go aren't bad engineers. Some of them are the best on the team. They just refused to pick up the new weapon. Being principled about not using AI is like being principled about not using electricity. You can hold the position. You can't hold the job.

But the coders who adopt face their own problem. Everyone is faster now. The advantage evaporates the moment it becomes universal. If eight people with AI do what twelve did without it, the company doesn't need twelve. The speed that saved your job is the same speed that eliminated four of your colleagues.

What if you could call AI the same way you call any other function?

Not a chat window. Not copy-paste. A typed function call with validated input, validated output, and a contract the AI has to meet.

A Semantic Function is a JSON specification that wraps an AI call in an engineering contract. Typed input fields with validation — what goes in. Typed output fields with validation — what comes out. A system message telling the AI its role. A prompt template with placeholders filled from input. Validation on both sides, before the call and after. If the output doesn't match the schema, it fails cleanly. No silent garbage. No hoping for the best.

Here's what one looks like. classifyTicket. Input: an email that says "My order is late!" Output: sentiment negative, category shipping, priority high. Anyone can ask ChatGPT to classify an email. Only a programmer can build a function that does it the same way every time, validates the result, and plugs into a pipeline of ten other functions.

This is why coders start feeling powerful again. The work is repeatable — same input, same contract, every time. It's portable — swap Claude for GPT for Ollama without touching the spec. The provider is a config line. It's composable — chain functions, output of one becomes input of the next, build real pipelines. It's testable — write real tests for AI behavior, assert on schemas, catch regressions.

And there's a tool that generates these specs from plain English. It bootstraps — uses a semantic function to create semantic functions. Describe what you want; get a validated spec.

Semantic Functions turn a coder from a prompt typist into an AI engineer. The work requires design, architecture, testing, integration. It requires a programmer. The coder strikes first.

But Code Wars has only begun. The AI companies have billions of dollars and thousands of engineers, and they're about to deploy something far more powerful than a chatbot.

That money buys data centers that consume the power output of small cities. Microsoft is restarting Three Mile Island under a 20-year deal to power AI. Amazon bought a nuclear-powered data center campus for $650 million. A single ChatGPT query uses ten times the electricity of a Google search.

In 2024, both OpenAI and Anthropic revised their policies to allow military use of their models. Both had previously prohibited it. Both changed their minds when the contracts appeared. The companies building the tools that are replacing your job are also selling those tools to the military. Same models. Same infrastructure. Different customers.

The coder isn't competing with a tool. The coder is competing with the output of the largest industrial investment in human history.

Then the agents arrive. Claude Code. Codex. Gemini Code Assist. They read files, write code, run tests, debug failures, and iterate until the tests pass. They don't get tired. They don't take vacations. They cost a fraction of a developer's salary.

"Vibe coding" became Collins Dictionary's Word of the Year in 2025. A company called Base44 — which lets people build apps by chatting — was acquired by Wix for $80 million after six months of existence.

Who needs coders when you have Claude Code? Honestly? For a lot of tasks — nobody.

Agents are powerful. But power without control is just explosions. The coder's advantage isn't that they can use an agent. Everyone can use an agent. The coder's advantage is that they can control one.

An Agent Function is the same idea as a Semantic Function — typed input, typed output, validated contract — but the "AI" is a coding agent. Claude Code, Codex, Gemini Code Assist. The agent reads files, writes code, runs tests, operates on the machine. The output is validated against a schema. Fail? Retry. Pass? Advance. Every step logged. Every cost tracked. Every decision auditable.

Anyone can order food. Building the kitchen, designing the menu, managing the supply chain, running quality checks — that's the job. Vibe coding orders food. Agent Functions run the restaurant.

The result is a pipeline. Fifteen steps from a text description to a finished product. Requirements extraction. Game design with iterative review. Architecture with quality gates. Implementation planning. Build. Test infrastructure. Then the core loop — evaluate and improve, up to seven iterations, each one finding and fixing the single most impactful issue by priority.

What has it built? Working games. From a sentence. The marketing manager built a dashboard in an afternoon. She cannot build this. This requires a programmer. This IS programming — at a higher level of abstraction.

But here's the honest truth. Even the coder's best weapons — semantic functions, agent functions, programmatic AI control — are still dependent on AI. Every call costs tokens. Every spec runs on someone else's model, someone else's infrastructure, at someone else's price.

You found a way to fight the Empire. But you're fighting with the Empire's own weapons, bought from the Empire's own store.

To win this war, you need something the Empire can't take away.

What is AI, actually? Strip away the mystique. It's a collection of what has already been — knowledge distilled from the honest work of millions of people. Their code, their papers, their Stack Overflow answers. It isn't thinking. It's pattern-matching across the largest library ever compiled.

For anything already solved, AI can produce a working implementation through guided iteration — test it, show it what correct looks like, let it converge. Left to iterate on its own, it degrades.

But for anything genuinely novel, it produces nothing. There's nothing to recombine. Original thought requires a brain. AI doesn't have one. You do.

And once you see it, it's everywhere. The AI systems you use every day — chatbots, coding assistants, cloud platforms, search — are already hybrids. Neural networks do the pattern-matching. Rules do the steering. When Claude writes a sentence, the neural network ranks possible next words — then a separate set of sampling rules makes the final choice. When you ask Claude or GPT-4 for structured output — valid JSON, a specific schema — a grammar-based constraint engine masks every token that would violate the schema before one is sampled. Rules enforcing structure, layered directly on top of the neural network. AWS runs a billion automated logic checks every day. AlphaGeometry — DeepMind's breakthrough math system — is openly built as a hybrid of neural network and rule-based reasoning. The techniques everyone thought AI made obsolete turned out to be holding everything together. Rules never died. They just went invisible.

If the rules are already there, the question was never whether they work. It's who writes them.

So don't rent AI's knowledge. Extract it.

Build a gold file — complete input-output pairs that show what "correct" looks like. A test tells the AI what's wrong. A gold file shows it what right looks like. Since the AI is already good at solved problems, it can help generate the gold file itself — produce the examples, you verify them.

Then hand it to an AI coding assistant: "Write a program that passes every one of these cases." Let it iterate — try, fail, fix, try again — automatically, with testing and gold-file validation at every step. Iteration converges where a single prompt never will.

What comes out is a program. No AI at runtime. Just code on an ordinary computer, producing the right answer every time. The gold file is the contract. If it passes, it works.

One research team had an AI write extraction rules for medical records — names, dosages, diagnosis codes — and the rule-based extractor scored near-perfect accuracy while the AI doing the same job made errors the rules didn't. Another team had an AI write decision rules for self-driving cars, and the rule-based driver outperformed both traditional approaches and advanced AI systems, with every decision traceable to a specific rule. The student surpasses the teacher by solving the problem a different way.

Alex ships the constraint solver the next morning. It runs on one laptop. No API calls, no usage graph, no monthly bill. No one else to pay, ever again.

One honest caveat. The bottleneck shifted, it didn't disappear. Writing rules is no longer the hard part — defining correctness is. Someone still has to know what the right answers look like, case by case, and getting them into a gold file takes real expertise. The method doesn't make the problem easy. It makes it possible — for a single person on an ordinary computer, where before it took a research team and a GPU cluster.

Take dependency parsing. Every production implementation runs on a neural network that can't explain its decisions. The one below, built with gold files, is the first ever written in JavaScript.

The Church-Turing thesis established that any Turing-complete system can compute the same class of functions as any other. Neural networks and rule-based systems are both Turing-complete. The barrier between them was never capability — it was effort. Writing rules by hand was too slow and too painful. Researchers had a name for it: the knowledge acquisition bottleneck. MYCIN matched human doctors with roughly 600 rules, but it took five years to build (1972–1976). Traditional knowledge engineering produced two to five rules per expert per day. That bottleneck collapsed the expert systems industry in the late 1980s — systems were too brittle, too expensive to maintain, and too slow to build — and the field entered its second AI winter. Neural networks eventually filled the vacuum, but not until the deep learning era two decades later.

Now hand an AI coding assistant a manual and a domain expert, and the expert reviews and corrects rather than creating from scratch. How many correct rules per hour can an LLM produce? The answer is an open question — and the right one to be asking. The AI that everyone thought made rules obsolete may turn out to be the best rule-writer in history. The bottleneck is flipping.

Every program you extract with the gold-file method is one you never pay for again. Do it enough times and you have a library — tested, verified implementations running without AI, under your control. The dependency parser above is one entry. The expert system is another. Each one runs in your browser with no AI in the loop. Each one replaces something that used to cost tokens every time it ran. Now picture a hundred of them. A thousand. Your own arsenal.

Now describe what you want to build — in plain English — and let AI assemble it from your components. Not from its training data. From your tested library. You provide the interfaces. AI plugs the pieces together. If a piece is missing, use the gold-file method to build it, test it, add it. The library grows. Every project makes the next one faster.

Take function calling. It's the technology everyone claims you need an LLM for — the thing that lets AI agents actually take action, not just talk about it. Claude Code uses it. Codex uses it. Siri and Alexa use it. Every chatbot that books a flight or checks an order uses it. Anthropic built an entire protocol around it — the Model Context Protocol, now adopted by every major AI company. And the demo below does it without an LLM at all. Zero cost, zero latency, every matching decision fully explainable.

Every call to an AI for something it's already done is a rental payment on knowledge that could have been owned. Do it enough times, over enough domains, and the library becomes the product. The AI helped build it. The AI isn't needed to run it.

The researchers who started this field seventy years ago had the right idea. They just didn't have an AI to help them write the rules.

Now we do.

Every one of these is an active work in progress. Every number is real and verified. Every claim is conservative. Each system is shipped in its current form and still being refined — which is the whole point of the method: the library grows; every project makes the next one faster.

1. An English dependency parser. 91.4% UAS and 89.7% LAS on Universal Dependencies gold — statistically tied with Stanford's Stanza neural parser (91.7% / 89.6%) on 6,125 sentences. 83.4% UAS on Stanford's own held-out English Web Treebank, climbing with every rule added. 10 MB total. Parses 6,125 sentences in 25 seconds — about 29× faster than Stanza on the same CPU. Zero neural inference at runtime. Runs in your browser.

Open the parser demo →

2. A classical music factory. A rule-based procedural composer in the style of Mozart, C.P.E. Bach, Kirnberger, Stadler, Haydn, Calegari, and Gerlach. 92% statistical fidelity to Mozart, 89% to Stadler Trio, 88% to CPE Bach on a suite of 20+ objective metrics — step ratio, contour balance, cadence shape, cross-relation rate, bass-rest distribution. 264 tests passing. Full browser-side pipeline: ABC to MusicXML to SVG to PDF to MIDI to WAV, with SoundFont-synth playback and 28-key transposition. ~670 KB per composer site. 0 LLM at runtime.

Play the composer →

3. An Upwork bidding expert system. A MYCIN-style decision engine — forward and backward chaining, certainty factors, triple-store knowledge base, skill taxonomy, justification graph, full what-if analysis. Every recommendation traces to specific rules and specific facts. Exactly four LLM touchpoints, each a typed Semantic Function: parse a job posting, parse a profile, estimate scope, draft a proposal. Everything else is deterministic. Works against any LLM provider — Groq, OpenRouter, Gemini, local Ollama. Runs in the browser with nine UI panels.

Open the expert system →

4. A resume site factory. Twenty themes, forty-plus section components, every build producing a self-contained static site plus PDF, DOCX, plain text, VCF, Open Graph image, sitemap, and robots. Build time for a full resume with PDF: about one second. Deterministic — same manifest, same output. No framework runtime, no hydration, no server. The tests include unit, component render, axe accessibility, and pixel-diff visual regression with golden hashes.

Open the resume gallery →

5. An art portfolio factory. Thirty themes, twenty-four section components, thirteen gallery layouts. Every build produces a landing page, per-work detail pages, a printable catalog, a PDF portfolio, a ZIP archive, a sitemap, a search index, and an RSS feed. ~1-second build for a twelve-image portfolio. Swap a theme by editing one line. Reorder sections by editing one array. No database, no framework, no server.

Open the portfolio gallery →

6. An idle game factory. A deterministic composer that turns a short feature description into a playable single-file HTML5 idle game. 600+ expert-system rules across 21 decision domains, 80+ presets spanning cozy management to eldritch deep to cyberpunk, auto-tuning via Monte Carlo simulation. Every choice explainable and traceable to a specific rule firing. The 68 playable games already generated sit on disk, each ~800 KB, each permanent.

Open the idle game gallery →

7. A D&D 5e campaign builder. A DM's co-pilot that turns a short brief into a complete session-by-session campaign binder — arc, NPCs, signed relationship graph, plot facts, contingencies, per-session encounters, handouts, and a coherence audit. 205 rules with MYCIN certainty factors, 10 orchestrated factories, 84 SRD 5.1 stat blocks, 80 creatures across CR 1/8 to CR 10. Seeded and deterministic: same seed, byte-identical output.

Open the campaign gallery →

Seven systems, seven domains. Each one began as a gold file. Each one ended as code that runs permanently, without API calls, without rate limits, without a subscription. The method does not care about the domain. The only thing that changes is the gold.

Follow the logic to the end. The AI companies spent hundreds of billions of dollars to build the most powerful knowledge-recombination engine in history. They trained it on the collected work of every programmer, every researcher, every engineer who ever published anything. They powered it with nuclear reactors. They sold it to militaries. They told coders their careers were over.

And the best use of that engine, it turns out, is building systems that don't need it.

The coder doesn't fight the Empire. The coder walks into the Empire's factory, uses the Empire's machines, and builds something the Empire can't take back. Every gold file extracted is a domain the AI companies can never charge for again. Every library component tested and verified is a piece of intelligence that runs on ordinary hardware, offline, forever, without permission from anyone.

The Empire funded its own obsolescence. And the people building the replacement are the same people the Empire said it was replacing.

The library components run in your browser right now. No AI at runtime. No API. No server. Just JavaScript, produced by the method this article describes. The English parser and sentence segmenter were built with gold files and tests — the parser took about three weeks, the segmenter a few days. The other components were built with an AI coding assistant and tests. The results aren't perfect. They're decent — and they're permanent. The AI is gone. The code remains.

The most complete demonstration is a natural language understanding pipeline with six stages: parse, interpret, resolve context, store and retrieve facts in a knowledge base, run inference, and generate a response. You can tell it “Mars is a planet,” ask “Is Mars a planet?” and get a reasoned answer — all in the browser.

For context: IBM assembled roughly twenty researchers over four to seven years to build Watson’s DeepQA system — a far more sophisticated pipeline, but built on the same foundations of parsing, knowledge retrieval, and inference. The original Siri grew out of DARPA’s $150 million CALO program, which took over 300 researchers across 22 institutions five years to produce. MYCIN took a small team five years (1972–1976). One person built the demo below in under a month.

The honest question isn't what these demos can do today. It's what this method can produce at scale.

Everything in this article comes together in one place. An astronomy tutor that runs in your browser with an animated companion, a knowledge base of over 5,000 facts, an inference engine, a dependency parser, a spelling corrector, a sentence segmenter, an intent matcher, a dialog manager, and a natural language generator. You can ask it questions, tell it facts, write haiku, play chess, fly through asteroids, or land on the moon. All of it runs without an LLM.

When the tutor encounters a question it cannot answer from its knowledge base, it asks an LLM for help. But it doesn't just show you the answer. It converts the response into structured facts and adds them to its own knowledge base — on the server and in your browser. The next time anyone asks the same question, the tutor answers from its own knowledge. No LLM needed. It got smarter.

Every question the tutor can't answer today is a question it will be able to answer tomorrow. The LLM teaches. The tutor learns. And eventually, the tutor stops needing the teacher.