What is the EARS requirement syntax for AI code generation and how do you write it?

What EARS Actually Is and Why It Matters for AI Code Generation

The Easy Approach to Requirements Syntax (EARS) is a five-pattern template system originally developed at Rolls-Royce for safety-critical aerospace and embedded systems work. It was published by Alistair Mavin and colleagues in 2009 and has since been adopted across regulated industries because it removes the ambiguity that plain English requirements tend to carry. In 2026, EARS has crossed over into AI-assisted software development because large language models produce more deterministic, testable code when the prompt they receive is structured rather than freeform. The five EARS patterns are Ubiquitous, Event-driven, State-driven, Unwanted behaviours, and Optional features, and each one uses a fixed keyword prefix that an AI agent can parse without ambiguity.

Also worth reading: What are the enterprise RAG security best practices for protecting retrieval-augmented generation systems in 2026? · How do technical writers optimize AI workflows for accurate and efficient documentation? · How can engineers optimize thermal storage efficiency for industrial and grid-scale applications?

The reason EARS works well for AI code generation is that the syntax collapses the natural-language requirement into a single conditional clause with a clearly named trigger, a clearly named subject, and a clearly named response. When an engineer writes "When the user clicks Submit, the system shall validate the email field," the model receives a recognisable template rather than a paragraph it has to interpret. This matters because most production failures in AI-generated code in 2026 trace back to ambiguous prompts rather than model capability. AWS's Kiro tool, demonstrated at AWS Summit New York 2026, uses EARS-style structured requirements as the input layer for its spec-driven agent, and the aerospace-grade traceability it advertises is essentially EARS plus a verification matrix.

The Five EARS Patterns in Full

The Ubiquitous pattern is the simplest and is used for requirements that must always hold. It takes the form "The [subject] shall [action]." An example would be "The checkout service shall return HTTP 200 on successful payment." This pattern is appropriate for roughly 60 to 70 percent of functional requirements in a typical web application, and it is the default the AI agent should reach for when no trigger or condition is specified.

The Event-driven pattern handles requirements triggered by an external stimulus. Its template is "When [trigger], the [subject] shall [action]." A concrete example is "When the API receives a POST to /orders, the order service shall persist the order to the database within 200 milliseconds." The trigger must be a discrete, observable event, not a vague condition. AI agents frequently misfire when engineers write "When the system is slow" because "slow" is not observable. Replacing it with "When the p99 latency exceeds 500 milliseconds" gives the model a measurable threshold it can encode.

The State-driven pattern covers behaviour that only applies while the system is in a particular mode. Its template is "While [state], the [subject] shall [action]." An example is "While the maintenance window is active, the load balancer shall route 100 percent of traffic to the secondary cluster." This pattern is essential for any system with operational modes such as read-only, degraded, or maintenance, and it is the one most often forgotten by engineers writing specs for AI tools.

The Unwanted behaviours pattern, sometimes called the "shall not" pattern, captures forbidden actions. Its template is "If [condition], then the [subject] shall not [action]." An example is "If the user is not authenticated, then the API shall not return any user record." This pattern is critical for security requirements because it gives the AI agent an explicit negative constraint rather than relying on the model to infer what is forbidden.

The Optional features pattern handles behaviour that only applies under a configuration choice. Its template is "Where [feature is included], the [subject] shall [action]." An example is "Where the SSO module is enabled, the authentication service shall redirect to the configured identity provider." This pattern maps cleanly to feature flags and modular architectures, and it is the pattern that spec-driven tools like Kiro and Auggie use most heavily when generating conditional code paths.

How EARS Maps to AI Code Generation Workflows

In a typical 2026 spec-driven workflow, the engineer writes a set of EARS requirements in a markdown or YAML file, the AI agent parses each requirement into a structured object with subject, trigger, action, and verification fields, and the agent then generates code, tests, and documentation from that structured object. The verification field is what makes EARS particularly powerful for AI workflows: each requirement can carry an acceptance criterion such as "verified by unit test TC-014" or "verified by integration test IT-007," and the agent can then generate the test alongside the code.

The practical benefit is that the same EARS file can drive code generation, test generation, and documentation generation without re-writing the requirement three times. Augment Code's 2026 comparison of spec-driven tools found that teams using EARS-style structured inputs reported 30 to 40 percent fewer re-work cycles compared to teams using freeform prompts, and the AWS white paper on balancing speed and safety for AI coding agents recommends EARS as one of three input formats (alongside JSON Schema and Gherkin) for high-stakes code generation.

Comparison of EARS With Other Requirement Syntaxes

The table shows that EARS occupies a specific niche: it is more structured than user stories, more concise than Gherkin for non-test requirements, and dramatically more parseable than plain English. For AI code generation specifically, the keyword prefix is the deciding factor because it lets the agent classify the requirement before attempting to generate code.

Practical Steps for Writing EARS Requirements for an AI Agent

Step one is to identify the subject of each requirement as a single named component. Avoid pronouns and avoid compound subjects such as "the system and the database." A clean subject makes the generated code easier to locate and easier to test. Step two is to choose the correct EARS pattern based on whether the requirement is always true, triggered by an event, conditional on a state, a negative constraint, or optional. Step three is to write the action as a single observable behaviour with a measurable outcome wherever possible. Step four is to attach a verification reference, either a test ID or an acceptance metric. Step five is to review the file for ambiguity before handing it to the AI agent.

A worked example for a login endpoint might look like this: "The auth service shall reject requests without a valid JWT." (Ubiquitous.) "When the auth service receives a login request with valid credentials, the auth service shall return a JWT with a 15-minute expiry." (Event-driven.) "While the auth service is in maintenance mode, the auth service shall return HTTP 503 for all requests." (State-driven.) "If the rate limit is exceeded, then the auth service shall not process the request." (Unwanted behaviours.) "Where MFA is enabled, the auth service shall require a second factor before issuing a JWT." (Optional features.) Each of these five requirements maps to a single code path and a single test case, and an AI agent can generate both in a single pass.

Common Mistakes When Using EARS With AI Tools

The most common mistake is mixing patterns within a single requirement. A sentence that starts with "When" and ends with "and shall not" is two requirements, not one, and the AI agent will typically generate code that satisfies only the first half. The fix is to split the requirement at the conjunction and write two separate EARS statements. The second most common mistake is using unobservable triggers such as "when the user is frustrated" or "when performance is poor." These cannot be encoded as code because there is no measurable signal. The third most common mistake is omitting the subject, which forces the AI agent to guess which component the requirement applies to, and the guess is wrong roughly 30 percent of the time based on internal benchmarks from spec-driven tool vendors in 2026.

A subtler mistake is treating EARS as a documentation format rather than a generation format. If the engineer writes EARS requirements after the code is written, the value is largely lost because the AI agent has no opportunity to use the structure. EARS works best when it is the input to the agent, not the output of the engineer. Teams that adopt EARS retroactively to satisfy an audit requirement typically see no improvement in code quality, while teams that adopt it as the front-end of their AI workflow see measurable reductions in defect rates.

When EARS Is and Is Not the Right Choice

EARS is the right choice when the codebase has clear component boundaries, when requirements must be traceable to tests, and when the AI agent is being used to generate code in regulated or safety-critical contexts. It is the wrong choice for early-stage product discovery, where the requirements themselves are still being discovered, and for exploratory prototyping, where the overhead of writing five structured requirements per feature slows iteration. It is also a poor fit for machine learning model behaviour, where the requirement is statistical rather than deterministic and EARS's binary trigger/action structure does not capture the nuance.

For most production engineering teams in 2026, the practical recommendation is to use EARS for the 60 to 80 percent of requirements that are deterministic and well-understood, and to use plain English or user stories for the exploratory 20 to 40 percent. The AWS white paper on AI coding agents recommends this hybrid approach explicitly, and the spec-driven tools that have gained traction in 2026, including Kiro, BMAD, and GSD, all support EARS as one of several input formats rather than as the only format.

Cost, Tooling, and Adoption Timeline

EARS itself is free to use and requires no licence. The tooling that supports it ranges from free markdown editors with EARS linters to paid spec-driven platforms. Kiro's pricing in 2026 starts at $20 per user per month for the entry tier, with enterprise tiers priced on request. Augment Code's Auggie CLI is included in the standard Augment subscription, which starts at $30 per user per month. Open-source alternatives such as the BMAD method and the GSD workflow are free but require more manual setup. Adoption timelines vary: a team of five engineers can typically become productive with EARS in one to two weeks, and a larger organisation can roll it out across teams in two to three months with a dedicated requirements engineer. The return on investment is concentrated in regulated industries, where EARS-style traceability can reduce audit preparation time by 40 to 60 percent, and in AI-heavy teams, where structured inputs reduce code re-work by 30 to 40 percent.