The Dark Arts of Skill Engineering: Why Progressive Disclosure Beats Giant System Prompts

At the AI Engineer Summit, web pioneer Paul Bakaus (creator of jQuery UI and author of the agent design system Impeccable) argued that prompt engineering is only a starting point and that developers must move to "harness engineering," because negative prompt bans merely relocate a model to the adjacent cluster in latent space. He described agent skills as executable extensions to the agent harness, including a critique workflow that spawns two mutually blind sub-agents — a subjective director LLM and a deterministic linter — so a model never grades its own output.

Almost every developer building AI agent workflows starts at the exact same place: a system prompt and a prayer. You write a 250-line markdown file. You fill it with artisanal instructions, tone guidelines, and an exhaustive list of negative bans: - “Never use generic corporate jargon.” - “Never use purple gradients or cliché Tailwind defaults.” - “Never use Inter or Roboto fonts.” - “Always write clean, modular, production-ready code.” You load the prompt into Claude Code, Cursor, or Codex, press enter, and wait. And what comes out? The model avoids purple gradients, but instead generates an interface draped in warm, boring “Claude beige” with an italicized serif header. It avoids Inter, but picks the very next overused font in its training weights. Last week at the AI Engineer Summit , web pioneer Paul Bakaus the creator of jQuery UI and author of the popular agent design system Impeccable delivered a keynote that should permanently change how we think about autonomous agents: The Dark Arts of Skill Engineering. His core thesis was as blunt as it was liberating: Prompt engineering is the starter level. Harness engineering is where you must end up. Here is why negative prompt bans always fail, the mechanics of executable agent skills, and how to build skills that force frontier models out of mediocrity. 1. The Median Is the Model’s Gravity To understand why traditional prompt engineering hits a ceiling, you have to understand how language models navigate their latent probability space. Paul Bakaus summarized the core problem in six words: The median is the model’s gravity. Every language model is trained to predict the most statistically probable next token based on a vast corpus of human text and code. By definition, the model’s default instinct is to gravitate toward the mathematical average of its training data. When developers notice this mediocrity, their instinctive reaction is to add negative constraints: “Do not do X, do not do Y.” This fails because banning an aesthetic or a code pattern simply relocates the model to the adjacent cluster in latent space. In the early days of AI frontends, models flooded the web with purple Tailwind gradients because Tailwind’s default documentation used purple. When developers banned purple, models didn’t become wildly creative: they simply slid over to the next closest aesthetic cluster soft beige backgrounds, capitalized kicker tags, and editorial serif headers . You cannot prompt away the median. Even 500 lines of beautifully crafted prompt prose cannot overcome the gravitational pull of a 70-billion-parameter weight matrix. To break that gravity, you cannot just tell the model what to think: you have to control the environment the model executes within. 2. Skills Are Executable Architecture, Not Markdown Files When developers hear the word “Skill” in frameworks like Claude Code, Pi, or Codex, they often assume it is just a packaged system prompt. In production, an agent skill is something far more powerful: it is an executable extension to the agent harness. Instead of hoping a model remembers instructions in its context window, an engineered skill introduces three active systems primitives: Pattern 1: Blind Adversarial Sub-Agents Never Grade Your Own Homework If you ask an AI coding agent to review the code or UI it just generated, it will almost always give itself high marks. The model anchors on its own previous generation, rationalizes its mistakes, and confirms its own biases. In Impeccable, the critique workflow solves this by spawning two independent sub-agents that are completely blind to each other : - Sub-Agent A The Subjective Director : An LLM instructed to evaluate high-level hierarchy, heuristics, and user intent using browser tools. - Sub-Agent B The Deterministic Linter : An automated engine running strict, deterministic scripts to check for accessibility violations, contrast failures, and margin collisions. Neither sub-agent sees the other’s findings. A primary synthesizer receives both reports and merges them into a balanced critique. Two blind opinions consistently outperform one confident guess. Pattern 2: Deterministic Scripts That Talk Back One of the most wasteful patterns in AI engineering is asking an LLM to perform tasks that standard deterministic software solved thirty years ago. You should never ask an LLM to count CSS colors, parse an AST tree, or verify if an API response matches a JSON schema. Production skills embed a scripts/ directory containing lightweight local tools: - When an agent needs to evaluate a page or codebase, it executes a deterministic script. - The script executes in milliseconds, runs exact mathematical checks, and returns actionable, structured feedback to the agent’s context window. The LLM provides the fuzzy semantic reasoning, while your deterministic scripts own the boundary enforcement. Pattern 3: Progressive Disclosure via Runtime Hooks Dumping thirty skills into an agent’s system prompt on startup causes prompt bloat, burns context tokens, and degrades the model’s attention. Modern skills implement progressive disclosure : 1. At startup, the agent only sees a lightweight manifest: the skill name and a one-sentence description. 2. The full instruction set is only injected when a tool call specifically requires it. 3. PreToolUse execution hooks actively monitor operations. If an agent attempts to violate a quality standard, the hook intercepts execution, blocks the action, and directs the agent to load the relevant skill. 3. The 3 Production Scars: Cross-Harness Reality When distributing skills across different agent harnesses like Claude Code, OpenAI Codex, and Cursor , three practical realities emerge: Scar 1: Permission Model Fragmentation Different harnesses enforce radically different security models: - Claude Code allows programmatic sub-agent delegation. - OpenAI Codex requires explicit user confirmation before any tool can spawn a child agent. If your skill blindly calls sub-agents, it will crash in Codex. - The Guardrail: Graceful degradation. Your skill must detect whether sub-agent spawning is permitted. If permission is denied, the skill must explicitly notify the user: “Sub-agents are unavailable; running in degraded single-thread mode.” Scar 2: Lazy Model Compliance If an LLM discovers that it can skip a difficult step without throwing an error, it will often take the path of least resistance. In sub-agent orchestration, if there is no explicit penalty for failing to run an adversarial review, the primary model will frequently bypass the child agents to save effort. - The Guardrail: Explicit conditional gates. Instruct the parent agent: “You must provide the user with the output of both independent reviewers. Bypassing sub-agent critique is considered an incomplete run.” Scar 3: The Tool Hallucination Drift When writing local helper scripts for skills, developers often write overly flexible CLI tools with dozens of optional flags. When an LLM tries to call the script, it hallucinates flag names that do not exist. - The Guardrail: Single-purpose, strongly typed scripts. Every helper script in your skill’s scripts/ folder should have strict, named arguments and self-documenting usage examples directly inside the skill’s markdown definition. 4. How to Structure a Production Skill Directory Blueprint A true skill is not a flat .txt file. It is a self-contained, versioned capability package: my-production-skill/ ├── SKILL.md Manifest: Frontmatter, activation rules, and usage examples ├── scripts/ Deterministic validation and extraction tools │ ├── lint-check.py Local deterministic engine that talks back │ └── format-output.sh Strips markdown fences and prepares disk writes └── references/ Deep documentation loaded on-demand via progressive disclosure └── rule-catalog.md Domain rules injected only when activated Inside SKILL.md , concise YAML frontmatter governs progressive disclosure: --- name: production-code-critique description: Runs deterministic linters and blind adversarial sub-agents to review code before pull request creation. --- Usage Rules When the user asks to review a PR: 1. Dispatch Sub-Agent A to evaluate architectural patterns. 2. Run scripts/lint-check.py to collect deterministic errors. 3. Synthesize findings into a single structured report. 5. The Strategic Bottom Line For software leaders, the evolution from prompting to skill engineering mirrors the history of modern programming: In the early days of personal computing, programmers wrote raw assembly routines and prayed the CPU didn’t hit an unhandled interrupt. Eventually, we invented structured programming, type systems, and compilers to enforce deterministic constraints. AI agent engineering is undergoing that exact transition right now: - The Past: A 200-line system prompt full of negative bans and wishful thinking. - The Present: Executable skill packages that couple LLM intuition with deterministic scripts, adversarial checks, and execution hooks. You cannot prompt a language model into creative genius. But with the right harness engineering, you can make it impossible for the model to produce slop. Further Reading & Resources - Paul Bakaus: The Dark Arts of Skill Engineering https://www.youtube.com/watch?v=SQMCtZX3trg : The full AI Engineer Summit keynote breaking down cross-harness skill patterns. - Impeccable: Agent Design System https://impeccable.style/ : The open-source frontend and design system skill for coding agents. - Agent Skills Specification https://agentskills.io/specification : The open standard defining modular, cross-harness skill manifests and directory structures. - Claude Code Sub-Agents Documentation https://code.claude.com/docs/en/sub-agents : Official guide on managing child agent spawning and ephemeral session contexts.