Parenting Claude: Implementing Project Contracts to Tame Non-Deterministic AI in Web Development

The rapid integration of Large Language Models (LLMs) into the software development lifecycle has fundamentally altered how web applications are built, tested, and deployed. As developers move from deterministic, step-by-step coding processes to the unpredictable nature of AI-assisted workflows, the industry faces a critical challenge: maintaining code quality, security, and accessibility without stifling the productivity gains promised by artificial intelligence. At the recent WordCamp US, industry expert Chris Reynolds, Senior Manager of Developer Relations at Pantheon, proposed a framework to address this: the "Project Contract."

The Evolution of AI-Assisted Development

The last three years have marked a transformative shift in web development. Prior to 2023, coding was largely characterized by manual, deterministic logic where specific inputs yielded predictable, repeatable outputs. However, the emergence of advanced LLMs like Claude has introduced a paradigm shift. Developers are increasingly utilizing these models to automate boilerplate code, scaffold new applications, and debug complex legacy systems.

According to industry surveys from 2025, approximately 65% of enterprise web developers now utilize some form of AI coding assistant in their daily workflows. While this has significantly lowered the barrier to entry for non-traditional developers—often referred to as "vibe coders"—it has also introduced substantial risks. Because LLMs prioritize the fastest path to completion, they often bypass best practices, ignore security protocols, or introduce subtle vulnerabilities that are difficult to detect during standard peer reviews.

Understanding the Non-Deterministic Challenge

The core issue identified by developers like Reynolds is the non-deterministic nature of current AI models. Unlike a standard compiler or linter, an LLM generates responses based on probabilistic patterns. When a developer provides a prompt, the model does not "think" in the human sense; it navigates a vast neural network to predict the next most likely token.

This lack of predictability is a significant departure from traditional software engineering. When an LLM is asked to perform a task, it may successfully execute the command while simultaneously introducing "hidden" chaos—such as hardcoded secrets, lack of accessibility attributes, or improper memory management. If a developer assumes the model is acting with the same logical constraints as a human, they risk deploying unstable or compromised code.

The Project Contract: A Framework for Guardrails

To mitigate these risks, Reynolds introduced the concept of a "Project Contract"—a structured set of automated rules, checklists, and agent-based reviewers integrated directly into the coding environment. This methodology ensures that any code generated by an LLM is subjected to rigorous validation before it can be merged into a production repository.

The technical implementation of this contract typically involves:

• Claude.md Configuration: A project-specific documentation file that dictates the behavior, coding standards, and architectural preferences for the AI within a given repository.
• Reviewer Agents: A secondary, specialized AI agent tasked specifically with auditing the output of the primary coding agent. This agent acts as a gatekeeper, cross-referencing the code against a mandatory 40-to-50-point checklist.
• Pre-commit Hooks: Automated system checks that prevent any code from being committed to version control unless the reviewer agent has generated a formal "approval" file, complete with a verified timestamp.
• Test-Driven Development (TDD) Enforcement: Requiring the AI to write unit tests before writing the functional code. This ensures that the model is constrained by the very tests it creates, reducing the likelihood of regressions or refactoring errors.

Security and Data Integrity

One of the most pressing concerns within this new development landscape is the potential for AI to leak sensitive data. Automated agents, if not properly sandboxed, may inadvertently include API keys, database credentials, or proprietary configurations in generated code files. The Project Contract framework addresses this by embedding strict rules that explicitly forbid the inclusion of secrets. By codifying these security requirements, developers can enforce a "security-first" approach that does not rely on human memory or manual oversight.

The Changing Role of the Developer

The rise of AI-assisted development is forcing a re-evaluation of the professional software engineer’s role. If the primary task of a junior or mid-level developer is shifting from writing code to reviewing AI-generated output, the industry must address the "bottom-rung" problem. Historically, entry-level coding tasks were the training ground where junior developers learned the nuances of architecture, security, and debugging. By offloading these tasks to AI, there is a risk that the pipeline for developing senior-level expertise will be severely disrupted.

Industry leaders suggest that the future of the profession lies in "agent orchestration." Instead of a single AI model, developers will manage a suite of specialized agents—one for planning, one for coding, one for testing, and one for security auditing. The developer’s role evolves into that of a high-level architect or "parent" to these systems, responsible for defining the contract and managing the guardrails.

Broader Industry Implications and Future Outlook

The shift toward AI-centric development is not without its environmental and ethical costs. The massive computational power required to sustain these LLM-driven workflows has led to a surge in demand for data centers, raising concerns about the carbon footprint of the tech industry. Furthermore, the reliance on these "black box" systems remains a point of contention among regulators and privacy advocates.

As of late 2026, the consensus among developers is that while AI can significantly accelerate productivity, it cannot yet replace the human capacity for nuanced decision-making and ethical oversight. The "Project Contract" serves as a bridge, allowing developers to harness the power of LLMs while maintaining the rigor and reliability expected of professional software.

Looking forward, it is anticipated that IDEs and development platforms will begin to integrate these "contractual" guardrails natively. Rather than requiring developers to manually build complex reviewer agent systems, the tools themselves may come equipped with built-in, configurable policies that enforce best practices, security, and accessibility by default.

Ultimately, the goal is to reach a state of "trust but verify." By treating AI as an unruly but talented junior developer that requires constant supervision, the engineering community can navigate the transition into a post-deterministic era. The success of this transition will depend on the willingness of developers to embrace new, often counter-intuitive workflows that prioritize oversight over raw speed. As the industry continues to evolve, the distinction between a "coder" and a "system orchestrator" will likely continue to blur, placing a premium on those who can effectively define the rules of the road for the machines they command.