OpenClaw Skills for Angular Developers: The Complete List

Angular has undergone a quiet revolution. Signals, standalone components, the new control flow syntax, and improved server-side rendering have modernized the framework while keeping the batteries-included philosophy that Angular teams rely on. But most AI agents are still trained on Angular code from the decorator-heavy, module-based era.

The OpenClaw skills listed here bring your agent up to date with Angular as it exists in 2026. Each skill teaches specific patterns and conventions so your agent generates modern Angular code — not the patterns from Angular 12 tutorials. Browse the full collection on the OpenClaw Bazaar or start with the essentials below.

Signals

angular-signals-patterns

Installs: 13,900 | Author: signals-guild

Signals are the most important addition to Angular since standalone components. They replace the zone.js-based change detection model with fine-grained reactivity, and they change how you think about data flow in Angular applications.

This skill teaches your agent to:

• Use signal() for component state instead of plain class properties
• Derive values with computed() instead of getters or manual recalculation
• React to changes with effect() when side effects are needed
• Use input() and output() signal-based component APIs instead of @Input() and @Output() decorators
• Implement model() for two-way binding with signals
• Convert between signals and observables using toSignal() and toObservable() for interop with existing RxJS code

Without this skill, your agent defaults to the older patterns — @Input() decorators, ngOnChanges lifecycle hooks, and zone-based change detection. That code still works, but it misses the performance and readability benefits that signals provide.

openclaw skill install angular-signals-patterns

angular-signal-store

Installs: 7,200 | Author: ngrx-community

The NgRx Signal Store is the signal-based state management solution for Angular. This skill covers store creation, feature composition, entity management, and the withMethods / withComputed / withHooks patterns.

It pairs naturally with angular-signals-patterns and provides a lighter alternative to the full NgRx store for applications that need shared state but not the full Redux pattern.

Standalone Components

angular-standalone-architecture

Installs: 15,200 | Author: ng-arch

This is the most installed Angular skill on the Bazaar. Angular's shift from NgModules to standalone components is complete, and this skill ensures your agent writes standalone-first code.

The skill covers:

• Component creation: generating standalone components with standalone: true and direct imports
• Routing: configuring routes with provideRouter and lazy-loaded standalone components
• Dependency injection: using inject() function instead of constructor injection
• Provider configuration: setting up application-wide and route-level providers without modules
• Migration patterns: converting module-based code to standalone incrementally

The skill also teaches the new control flow syntax (@if, @for, @switch) that replaces structural directives, and the @defer block for template-level lazy loading.

openclaw skill install angular-standalone-architecture

angular-component-patterns

Installs: 8,600 | Author: ng-patterns

Goes deeper on component design: content projection with ng-content and @ContentChild, host element binding, view encapsulation strategies, and dynamic component rendering. This skill is valuable for teams building shared component libraries or design systems in Angular.

NgRx

angular-ngrx-modern

Installs: 11,100 | Author: ngrx-community

NgRx remains the most adopted state management library for enterprise Angular applications. But NgRx has evolved significantly — the boilerplate-heavy patterns of NgRx 8 are gone, replaced by createFeature, functional effects, and the signal store.

This skill teaches your agent modern NgRx patterns:

• Feature creators: using createFeature to generate actions, reducers, and selectors from a single definition
• Functional effects: writing effects as standalone functions instead of class-based services
• Entity adapter: managing collections with EntityAdapter for normalized state
• Component store: using ComponentStore for local state that is more complex than a signal but does not need to be global
• Selector composition: building efficient selectors that memoize correctly and avoid recomputation
• DevTools integration: structuring state for easy debugging with the Redux DevTools extension

The skill distinguishes between situations that warrant NgRx (complex shared state with many consumers, undo/redo requirements, audit logging) and situations where signals or a simpler approach is better.

openclaw skill install angular-ngrx-modern

angular-ngrx-effects-patterns

Installs: 5,400 | Author: ngrx-community

A focused companion skill for NgRx effects. Covers error handling strategies, retry patterns, effect coordination (dispatching multiple actions from one effect), and debouncing patterns for search-as-you-type features.

Testing

angular-testing-patterns

Installs: 12,300 | Author: ng-test-guild

Angular's testing story has improved substantially, but agents still generate tests with outdated patterns — deep TestBed configurations, synchronous tests for async components, and brittle DOM queries. This skill fixes that.

Key patterns the skill teaches:

• Lightweight TestBed configuration: using overrideComponent to stub dependencies instead of configuring entire module hierarchies
• Component harness testing: using Angular CDK component harnesses for reliable, maintainable DOM interaction
• Signal testing: asserting on signal values and computed state
• Service testing: testing services with TestBed.inject and mock providers
• HTTP testing: using HttpClientTestingModule (or the new provideHttpClientTesting) to intercept and assert on HTTP requests
• Async testing: handling zone-based and signal-based async operations correctly

The skill also covers the distinction between unit tests (test a component in isolation with stubbed dependencies) and integration tests (test a component with its real children) and when each approach is appropriate.

openclaw skill install angular-testing-patterns

angular-cypress-e2e

Installs: 4,800 | Author: e2e-patterns

End-to-end testing for Angular with Cypress. Covers page object patterns, Angular-specific selectors, intercepting HTTP calls, and testing route guards and resolvers in an e2e context.

RxJS Patterns

angular-rxjs-patterns

Installs: 10,600 | Author: rxjs-mastery

Even with signals handling more of the reactivity story, RxJS remains essential for Angular developers — HTTP requests, WebSocket connections, complex async coordination, and interop with existing codebases all rely on observables.

This skill teaches your agent:

• Operator selection: choosing the right operator for the job (switchMap vs mergeMap vs concatMap vs exhaustMap)
• Error handling: using catchError, retry strategies, and error propagation patterns
• Subscription management: avoiding memory leaks with takeUntilDestroyed, the async pipe, and toSignal
• Higher-order observables: flattening nested observable streams correctly
• Multicasting: understanding share, shareReplay, and connectable for shared streams
• Testing observables: using marble testing with TestScheduler for deterministic async tests

The skill is particularly strong on the interop between RxJS and signals — knowing when to convert an observable to a signal with toSignal and when to keep the observable for complex stream processing.

openclaw skill install angular-rxjs-patterns

angular-rxjs-error-handling

Installs: 4,100 | Author: rxjs-mastery

A focused skill on error handling in RxJS streams. Covers global error handlers, retry with exponential backoff, fallback strategies, and error recovery patterns that keep the user experience smooth when API calls fail.

Recommended Stack

For a modern Angular agent setup:

1. angular-standalone-architecture — the foundation for modern Angular code
2. angular-signals-patterns — fine-grained reactivity
3. angular-testing-patterns — test generation
4. angular-rxjs-patterns — async and stream handling
5. angular-ngrx-modern — if your project uses NgRx

These five skills transform your agent from generating outdated Angular code to producing the patterns that the Angular team actively recommends in 2026. The difference is immediately noticeable — standalone components, signal-based state, functional effects, and tests that do not break on every refactor.

Browse the Skills Directory

Find the right skill for your workflow. The OpenClaw Bazaar skills directory has over 2,300 community-rated skills — searchable, sortable, and free to install.

Browse Skills →

Built a Skill? List It on the Bazaar

If you have built a skill that others would find useful, publish it on the Bazaar. Reach thousands of developers and get feedback from the community.

Learn how to publish →