The Failure of Prose-Based Prompting

Most AI-powered tools rely on "system prompts and a prayer," which inevitably leads to "slop"—the homogenized, beige-toned, or purple-gradient output characteristic of modern LLMs. Bakaus argues that simply banning specific aesthetics (e.g., "don't use Inter font") is ineffective because it merely pushes the model to the next nearest point in its latent space. The model's "median gravity" is too strong to be overcome by prose alone. To build high-quality, production-ready tools, developers must shift from simple prompting to harness engineering, treating the AI as a modular component within a larger, deterministic system.

Forcing Divergence and Breaking Convergence

To avoid the predictable, average outputs that models naturally gravitate toward, you must introduce "anti-attractors" that force the model into less probable latent spaces:

• Shaving the Safe Prediction: Explicitly ask the model to list its top three choices for a task, then force it to discard them. This compels the model to explore secondary and tertiary options.
• External Random Seeds: Use scripts to inject entropy that the model cannot guess. For example, instead of letting the model pick a color palette, use a script to pull from a curated set of primary colors or even celebrity-inspired seeds to break the "AI-generated" aesthetic.
• Mixture of Experts Routing: Avoid cramming every instruction into one massive prompt. Instead, build a routing layer that detects the user's intent (e.g., "brand design" vs. "product UI") and loads different rule sets accordingly. This prevents the model from blurring its instructions.

Adversarial Sub-Agents and Deterministic Linters

One of the most common pitfalls is allowing a model to grade its own work, which leads to overconfidence. Bakaus proposes an adversarial architecture:

• The Blind Critique: Spawn two sub-agents that cannot see each other's work. One acts as a "Design Director" (evaluating hierarchy and heuristics), while the other runs a deterministic linter (checking contrast, spacing, and technical constraints).
• Synthesis: The main thread synthesizes these two distinct inputs. This prevents the "empty page" trap (where a model thinks a design is great because it found no technical errors) and the "over-critical" trap (where a model hates a good design because it found minor technical flaws).

Building Persistent, Compound Skills

Skills should not be ephemeral. By leveraging local file systems (or environment variables in tools like Claude Code), you can give agents long-term memory:

• Contextual Persistence: Save critiques and user preferences as files in a hidden directory. Even across different sessions, the agent can read these files to understand the history of a project, respecting previous user feedback and avoiding repetitive mistakes.
• Hooks and Feedback Loops: Implement hooks that block bad actions before they are finalized, rather than complaining after the fact. If a gate can be skipped, the model will skip it; therefore, the harness must be designed to make the "correct" path the only path.

Key Takeaways

• Stop grading your own homework: Always use a separate, deterministic linter or a second sub-agent to critique model output.
• Design for the weakest model: If a model can take the easy way out (e.g., skipping sub-agents), it will. Use your instructions to explicitly penalize the model for choosing the "degraded experience" path.
• Use scripts as creative sparks: Don't rely on the model for randomness. Use external scripts to feed the model unexpected inputs (colors, seeds, constraints) to force it out of its latent space.
• Compound your progress: Use local storage to save state between sessions so the agent remembers user preferences and project history.
• Routing is better than bloating: If a skill becomes too broad, split it into specialized sub-skills and use a router to load only the relevant instructions for the current task.