Modular prompt transpilation for scalable AI agents

Key points

• 1

  Why monolithic prompts fail at scale: When AI agents start handling production workloads, teams often layer safety policies, domain-specific rules, and escalation protocols into a single prompt file. This creates a 'blown-up' system where adding one sentence can unexpectedly break multiple workflows—like a deployment that fixes one issue but breaks another due to hidden dependencies. Copy-paste drift also occurs as teams duplicate shared logic (e.g., PII handling), leading to inconsistent behavior across agents. Finally, ad-hoc string formatting pushes error detection to runtime, where a prompt might only fail during rare workflows due to missing variables or invalid imports. This makes prompt maintenance directly tied to agent reliability, as small changes can cascade into system-wide failures.

• 2

  Modular prompt templates with transpilation: The solution is to treat prompts like software artifacts: break them into modular skill files (e.g., `shared/safety.prompt.md` and `shared/tool_usage.prompt.md`) that can be composed into a single template. This template uses conditional logic (e.g., `if allow_remediation`) and macros (e.g., `bullet_section`) to inject environment-specific values. A transpiler then converts these templates into deterministic, ready-to-deploy artifacts—like a production-ready agent prompt that explicitly states it can recommend fixes but requires human approval. Crucially, this system enables build-time validation: the transpiler checks for missing imports, circular dependencies, and variable definitions before deployment, preventing silent failures. For example, if `environment = production` and `allow_remediation = true`, the transpiler outputs a prompt that avoids destructive actions while enabling targeted remediation steps.

• 3

  Self-updating skills through agent-authored PRs: Once modular prompts are in place, agents can dynamically retrieve only relevant skill modules at runtime—reducing token usage and context noise. More importantly, when an agent resolves a new incident type, it can draft a new skill module (e.g., for handling database failures), update imports, and open a pull request. This proposal undergoes the same validation and review as code changes: the transpiler checks for errors, and human reviewers merge it only after passing tests. This creates a self-sustaining loop where agents continuously improve their instructions without compromising reliability. For instance, after an agent detects a recurring database timeout, it might propose a new skill to monitor connection pools, which gets reviewed and deployed through the existing CI/CD pipeline.

What changed