for(geeks)
Enterprise

• 2 min read

Google says prompts need builds, not blobs

Google argues production agent prompts should be modular, transpiled, and validated like software artifacts to avoid drift and runtime failures.

Image: Hacker News

A single giant system prompt may work when an agent is new. Google argues it stops working once that agent hits production.

In a post published July 16, 2026, the company says prompt design turns into a classic software-scaling problem as teams pile on safety policies, domain rules, formatting requirements, and escalation behavior. The result is a single instruction file that becomes hard to review, hard to test, and easy to break with small edits.

Google highlights three main failure modes with monolithic prompts:

  • Obscured blast radius: a small prompt change can affect the entire agent in ways reviewers cannot easily predict
  • Copy-paste drift: teams duplicate shared logic such as PII handling, safety rules, or escalation instructions, creating inconsistencies
  • Deferred runtime errors: ad-hoc templating can hide missing variables or bad imports until a rare workflow triggers a failure in production

The proposed fix is to treat prompts as build artifacts, not static text files. Instead of one monolithic prompt, teams should write modular skill files and compose them through a template layer with imports, variables, and macros. That lets organizations isolate behavior, separate concerns, and generate a deterministic, fully rendered artifact that can be tested, audited, and diffed before it ever reaches a model.

Build-time validation and drift checks

Google says a production-grade prompt transpiler should catch missing imports, undefined variables, and circular dependencies during the build process rather than at runtime. Modeling prompt fragments as nodes in a directed graph makes it easier to detect recursive imports before deployment.

Recommended reading

AI sprawl is testing cloud lessons fast

Figure 2
Figure 2

The same setup also supports drift checking in CI pipelines. Teams can regenerate the transpiled prompt from source — the golden file — and compare it with the committed artifact. If they differ, the build fails, ensuring the repository matches what is actually running in production.

Figure 3
Figure 3

Dynamic skills and agent-written pull requests

Google also recommends progressive disclosure for larger skill libraries. Rather than loading every prompt fragment every time, the base compiled prompt should hold non-negotiable rules such as identity and safety boundaries. At runtime, the agent can fetch only the task-specific skill modules it needs, reducing token use and limiting noise.

Figure 4
Figure 4

That modular structure opens the door to a more unusual workflow: agents proposing updates to their own instruction layer. In Google’s example, an agent that resolves a new type of incident could draft a new skill module, update imports, and open a pull request. The key point is that the agent is not changing its instructions live; the update still goes through the same validation, evaluation, and human review as any other code change.

Figure 5
Figure 5

Google’s bottom line is straightforward: as agents move deeper into critical workflows, prompts need the same versioning, validation, and deployment discipline as software.

Marcus Vance

Enterprise Editor

Marcus follows the money. He covers enterprise software, cloud architecture, and the tectonic shifts in Big Tech strategy. He translates dense earnings calls and complex M&A activity into actionable insights about where the industry is actually heading. If a tech giant makes a silent pivot, Marcus is usually the first to notice.

via Hacker News

// Keep reading