Rules that make an agent
write Angular properly.
UAAIR is a rule set an AI agent reads before it touches your Angular code. Not a prompt you paste — a standing set of constraints on naming, architecture, reactivity, accessibility and performance, so that what the agent produces looks like it came from someone who has shipped Angular before.
UAAIR shipped as a Cursor rule file, and sold as one. That is also the reason it is off sale: a rule set tied to one editor argues against everything else on this site, which is built on the idea that you bring the agent and we stay out of that choice.
The rework is about making the same rules work wherever your agent lives — Claude Code, Cursor, Codex, Zed — instead of only where they were first written. The content is the part worth keeping; the packaging is the part that was wrong.
There is no date, and there is no waiting list to sign up for, because a form that collects an address for a product with no ship date is a way of looking busy. If you want to hear when it is back, email hello@ng.guide and it will be a person who answers.
Fifteen numbered sections. Each one is a set of decisions already made, so the agent does not re-litigate them in the middle of your codebase:
A table, not a paragraph: what a component file, template, stylesheet, directive, pipe, service and injection token are each called, and which selector prefix belongs to app code versus library code.
Strict checking, inference where the type is obvious, `unknown` over `any` — and a standing instruction against placeholders and mock implementations, which is the failure mode of an agent left to its own devices.
Twenty numbered rules around one decorator skeleton: standalone by default, OnPush unless the projection is genuinely dynamic, host bindings in `host` rather than decorators, `inject()` over constructor DI, signals over properties, `viewChild`/`contentChild` over the decorator forms.
Semantic HTML first. `@if` / `@for` / `@switch` / `@let` over the structural directives, `@defer` for lazy content, class and style bindings instead of `ngClass` and `ngStyle`, reactive forms over template-driven.
Signals for local state, `computed()` for derived state, `update`/`set` rather than `mutate`, and pure transformations — plus what to do about fetching, caching and optimistic mutation.
One section each. Services get their own table: when `providedIn: root` is wrong, when a service should *be* the stream, how to keep hot observables alive with `shareReplay(1)` and tear them down with `takeUntilDestroyed`.
Never `.subscribe()` in a component except to bridge an imperative API, and unsubscribe through `DestroyRef` when you do. Cold-to-hot with `shareReplay`, `defer` to avoid eager execution, `computed()` to expose state to the template.
Co-located component, template, style and test; one barrel per package exporting only stable symbols; no nested barrels; one component per file, regardless of how small it is.
Roles and `aria-*` on every interactive component, state mirrored into `aria-expanded` and `aria-selected`, WCAG AA contrast, and the rule that a `div` with a `(click)` handler is not a button.
`defer` for heavy streams, pure pipes memoised, `runOutsideAngular()` where zone pollution is the cost, `NgOptimizedImage` for static images, lazy feature routes.
Validators and sanitisation, guards and interceptors, OWASP as the reference. Unit tests for critical paths, integration tests for component interaction, and explicit instructions about error handling and edge cases — the parts an agent skips first.
A six-step walkthrough building one button component end to end, there so the agent has a pattern to imitate rather than a list to obey.
The naming section, in part. This is the level of specificity throughout — an agent cannot guess its way past a table:
| Artifact | Convention | Example |
|---|---|---|
| Component file | kebab, suffix .component.ts omitted | date-picker.ts |
| Template | same base, .template.html omitted | date-picker.html |
| Stylesheet | same base, .style.css omitted | date-picker.css |
| Pipe | kebab, .pipe.ts omitted, name fooBar | format-number.pipe.ts |
| Token | CAPS_SNAKE | DATE_FORMAT |
The remaining fourteen sections ship with the product, not with this page.
Rules tell an agent how to write code it already knows how to write. They do not teach you anything — and if you cannot tell a good Angular decision from a bad one, a rule file only makes the bad ones arrive faster and better formatted.
The course is the other half of that problem. It runs through the same agent, on your machine, and builds a Material 3 component library one component at a time — so the judgement ends up in you rather than in a config file.