Agentic Engineering: Professional AI Workflows for Angular
Alexander Thalhammer
Experienced software developer and architect with 20 years of experience in planning and implementing web-based business applications. Certified professional trainer according to ISO/IEC 17024, 9 years teaching assistant at the University of Graz.
In this 2-day workshop, advanced Angular developers learn how to use AI not just occasionally to generate code, but as a traceable part of professional Angular development. The storyline is deliberately practical: we prepare an Angular workspace for AI agents, build repeatable Agentic Engineering workflows, and finally apply them to real legacy refactoring – in eight parts that build on each other.
We start with the foundation: an Angular workspace with project knowledge, style guides, security rules, and feedback loops that every AI tool can use – and a library of reusable agent skills, from Angular topics like Signal Forms and migrations to prototyping, Figma workflows, and component libraries.
Next come the two bookends of every piece of agentic work: prompts with observation, goal, constraints, scope, and check at the start – and reviews at the end that turn agent speed into shipped quality instead of regressions.
After that, we choose the right way of working: the workflow pyramid gives each task exactly as much structure as it needs – from bugfix to new app – and the autonomy ladder shows when agents may work unattended: from goal-driven runs to parallel sub-agents and agents in CI.
Finally, we put everything to work and look ahead: we modernize dusty legacy components into clean, signal-based Angular in small, verified steps – and close with what it costs, how the setup reaches your team and monorepo, and what the next model generation means for it.
By the end of the workshop, you will be able to:
- set up your Angular workspace for AI agents and secure it with the right guardrails
- use agentic workflows to create, improve, and review production code
- analyze and modernize legacy components in traceable steps
- keep costs under control and carry the setup to your team and monorepo
Prerequisites:
- advanced Angular knowledge and experience with production projects
- a working Angular dev setup: current Node.js, Angular CLI, and Git – the exact checklist arrives before the workshop
- ideally your own project, a project idea, or concrete refactoring questions from your daily work: the exercises are designed to run on your own code (a sample repo is available as a fallback)
- access to at least one active subscription for Claude, Codex, or Cursor – ideally more than one to choose from
Highlights
✅ Fully online: 2 days, 4 compact half-day blocks
✅ For advanced Angular developers with production project experience
✅ Proven and latest best practices for Angular
✅ Agentic Engineering with Codex, Claude Code, Cursor & MCPs
✅ Hands-on: live prompting, exercises, and pair prompting with the trainer
✅ Enterprise-ready guardrails: secrets, mandatory reviews, and quality gates
✅ Sample repo, slides, exercise materials, and case study as a blueprint for your own projects
✅ Printable cheat sheet: prompt anatomy, workflow pyramid, autonomy ladder, and refactoring blueprint on one page
Agentic Engineering Workshop Agenda:
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
Upcoming events
Reviews
I also appreciated the concrete examples of how to implement DDD in folder and files structures.
Individual In-House Company Workshops
All of our workshops are also available remotely or in-house at any time.
Contact us for an appointment
FAQs on our workshops
How do your workshops and courses work?
Our seminars around Angular are a mixture of lecture, live coding and actual exercises. Together we implement what we have learned during the workshop directly on a example project. This mixture guarantees that the course never gets boring and “hands-on” is required instead of gray theory.
Who is the Angular hands-on training designed for?
Our Angular hands-on workshop is aimed at anyone who wants to develop applications with Angular in the future or is already doing so and now wants to better understand the background, context and building blocks of the framework.
Participants should have basic knowledge of web development (basic knowledge of HTML and JavaScript).
For advanced Angular developers we offer advanced seminars and intensive trainings on specific use cases.
Where do the Angular workshops take place?
Our trainings take place as public workshops in seminar rooms at central hotels in Germany, Austria and Switzerland. In-House company workshops take place at your office or conference room.
All courses are also available as remote workshops, where we meet online in a virtual classroom and do the training via video calls, screen sharing and live coding.
Who are the trainers?
Our workshops are held by experienced trainers and software architects. In recent years, we have provided Angular training to well-known companies – including well-known banks, insurance companies, industrial groups. Trainers include well-known conference speakers, authors of books and professional articles, bloggers, Google Developer Experts and university lecturers.
At what times are the training sessions held?
Especially for dedicated company trainings, we are happy to accommodate you. Typical times are 9:00AM to 4:30PM / 5:00PM. Some of our English-language workshops are timed so that you can also attend at US friendly times.
Can we also book online training courses?
Absolutely. In fact, since the pandemic, this has been our main business model and we have had very good experience with it. We use a combination of screen sharing, interactive online whiteboards, and are happy to connect to your computer for support during the exercises if you wish. As with our on-site training, we use a combination of short presentations, discussions, live coding and hands-on labs.
Since there is no travel involved, you also save time and money. We can also respond more flexibly to your scheduling needs.
Can we adapt the training for our purposes?
Yes, very much so. In fact, that’s one of the benefits of dedicated corporate training. You are welcome to weight, shorten or add to our agenda proposals. As a rule, we also coordinate with your trainer about 2 weeks before the training. If you wish, we can also arrange it earlier.
Why Angular?
Among other things, Angular’s wide distribution speaks for itself, but also the fact that Google, an Internet giant that also uses the framework very intensively, is behind it. Google alone has over 2600 solutions based on it. Due to the wide distribution, there is a large community and thus a lot of know-how on the market as well as (free and commercial) products that are adapted to Angular. In addition, Angular provides much of what you need for large applications out of the box: test automation, form management, routing, etc. In this respect, you get a stack whose components are coordinated and work together in the long term.
How do you compensate for different prior knowledge?
The good news up front is that participants with different levels of prior knowledge are the rule, not the exception, in adult education. That’s why you’ll find optional fade-in hints and bonus exercises on our exercise sheets, for those who are a little faster. Of course, we also provide personal support for the exercises.
How many participants are recommended?
If you book a company training with us, we leave this decision to you in principle. However, experience shows that there should not be more than 15 participants, especially since a seminar lives very much from questions, discussions and practical exercises.
What software do we need?
Please install the following software packages on your computer:
– NodeJS in current version (we test with current LTS version).
– Angular CLI (npm i -g @angular/cli)
– Git
– Visual Studio (free) or WebStorm/IntelliJ (commercial)
Selected happy customers
