Professional AI Workflows for Angular

More productivity through agentic AI workflows for Angular projects and legacy refactoring

Part 1: Setup - Preparing an Angular Project for AI Agents

Project setup: Angular strict mode, Git, ESLint, Prettier, Husky, and lint-staged for reproducible checks
Highlight: Our Angular Best Practices Rules & Style Guide for AI and teams: custom rules based on the official Angular best practices, extended with additional refinements, special rules, and project guardrails for AI tools
Project knowledge for agents: AGENTS.md, per-file-type style guides, and thin tool-specific instruction files
Security: secrets handling and per-tool deny rules, plus central lint/type/build checks for CI
Tool setup: Codex, Claude Code, and Cursor compared, plus VS Code, JetBrains, and other IDEs
Choosing MCP servers deliberately: Angular CLI, Chrome DevTools, Figma, GitHub, Playwright – every server costs context and trust
Feedback loops: lint, build, dev server, Chrome debugging, and e2e tests as verification signals for agents
Outcome: an Angular workspace whose rules, permissions, and feedback loops every AI tool can use

Part 2: Agent Skills - Reusable Capabilities for Angular and the Development Process

Why skills keep the context clean: a lean AGENTS.md, loading knowledge only when the task needs it
Angular skills in practice: components, Signal Forms, data access, SignalStore, migrations, accessibility, performance, security, and tests
Process skills: code review, bug diagnosis, test-driven development, prototyping, and handover
Creating, maintaining, and sharing your own skills across the team
Adopting third-party skills: documenting origins, adapting them, and scanning for risks before installing
From prototype to component: scope, API, data flow, loading/error/empty states, accessibility, and targeted tests
UX, UI, and Figma workflows: prompting, Figma MCP, Code Connect, design feedback, and review loops
Component libraries: Angular Material, PrimeNG, Spartan/UI: agent-friendly APIs, design tokens, and the path toward your own design system
Outcome: a skills library that makes every agent run the same processes in every session

Part 3 - Prompting & Context: How Every Piece of Agentic Work Starts

The anatomy of a good prompt: observation, goal, constraints, scope, and check
Three levels: the simple prompt, the interactive prompt with clarifying questions, and the intense session (plan interview or brainstorming)
Context is part of the prompt: paths instead of descriptions, screenshots as the observation, skills for the process
The context window as a budget: one task per session, compacting with care, handover documents between sessions
Anti-patterns: vague verbs, mega-prompts, missing constraints, and missing checks
Outcome: prompts with predictable results – and a feel for when clarification must come before code

Part 4: Reviewing - How Every Piece of Agentic Work Ends

The ground rule: every agent diff is a draft – the human reviews and commits
Machines go first: build, lint, format, and tests run before any human look
Picking an explicit review scope: current changes, staged work, last commit, or branch/PR
The two passes: correctness against the requirements, then style-guide conformance
Independent agent reviews with a fresh context, plus specialized reviews for architecture and style-guide drift
Acting on findings: verify each one, act by severity, push back with evidence
Outcome: a review process that turns agent speed into shipped quality instead of regressions

Part 5: Human-in-the-Loop Workflows - Structure That Matches the Size of the Work

The workflow pyramid: from bugfix to work package, feature, epic, and new app
Dosing the process: a spec, plan, and phases only when a wrong assumption would be expensive
Every transition is a checkpoint: spec, plan, phases, and diff pass your review before the agent continues
Working in parallel with Git worktrees: several agents on independent tasks, integrating results one at a time
Outcome: a decision model that gives each task exactly as much process as it needs

Part 6: Autonomous Workflows - Letting Agents Work Unattended

The contract before every unattended run: a verifiable goal, a feedback signal inside the run, and guardrails
The autonomy ladder: goal-driven runs, recurring loops, orchestration with sub-agents, and always-on agents
Model routing for sub-agents: instructions that control which app and model handle subtasks – e.g., Fable in Claude Code delegating subtasks to Codex with GPT-5.5
Agents in CI: scheduled maintenance, issue-triggered implementation, and fixing red builds via pull request
PR review bots: bots comment, humans merge – findings count only after verification
Hardening: permissions and deny rules, handling prompt injection, vetting MCP servers like dependencies
The review is only deferred: at the end of the run instead of at every boundary
Outcome: clear criteria for when a run may go unattended – and a setup that keeps it contained

Part 7: Agentic Refactoring: From Legacy Components to Modern Angular

The 7-step blueprint: analyse, declutter, update, modernize, type, refactor, and review
Guardrails: no big-bang rewrite, small traceable steps, and every change has to earn its keep
Verification after every step: build, lint, format, and tests – plus a behavior safety net before production code changes
ng update and official migration schematics: standalone, control flow, inject(), and signal-based input()/output()
Modernizing: replacing lifecycle hooks, OnPush, computed() for derived state, Signal Forms, SignalStore only for genuinely shared state – zoneless as the bonus round
From one component to the whole codebase: build the quality frame once, then work component by component in small commits
Outcome: a repeatable refactoring process that works for real legacy codebases in a team

Part 8: Outlook: Costs, Team Adoption, and the Next Model Generation

Cost models: flat subscriptions for people, token pricing with spend caps for pipelines and autonomous runs
Matching model strength to the task: inexpensive models for mechanical work, the strongest for planning and review
Measuring value in reviewed, merged diffs instead of tokens burned
In the team: AGENTS.md and the style guide as shared, PR-reviewed contracts; committing skills; clear PR ownership
Scaling to Nx monorepos: nested instruction files, the Nx MCP, nx affected, and caching
Growing with model generations: re-validating and shortening instruction files regularly
Your first week after the workshop: concrete todos for adopting this in your own project
Outcome: a plan for carrying the setup to your team, your monorepo, and the next model generation

"Excellent course! The instructor really knows his material and conveys it well."

Patrick Lecouffe

Christie Innomed

"Great course. Well prepared and presented. Trainer really knows his subject, and explains really well. Easy to follow. Teaching and Workshop is well balanced. "

Jefry Denny

SAP

"Thanks again for a great training session. This is going to be so useful getting me in the right direction as I finally embark on my 1st project which will use Angular for the front end. Your training is worth every second and every penny spent :)"

Pierre G.

"This is an amazing course. Laurent is one of the great trainers out there!"

Eric C.

"Angular Academy is one of the best training provider out there with a prolific tutor, I was so lucky to be tutored by Laurent!"

Abdulkabir O.

"I took the Angular Fundamentals course. I liked the structure and the dynamic of the training. Laurent is very good to pick-up the important and complex topics and explain them in a simple and concise way. His approach doing hand-on labs on the way expedites learning. Pretty happy with all the useful web resources he shared with us!"

Aldo Cuevas

SAP

"Great course! The instructor was very attentive."

Nassim Bencheikh

Christie Innomed

"Excellent training!!!"

Bhavesh Patel

Fiix Software