← Back to list
✍️

angular-architect Checked

Generates Angular 17+ standalone components, configures advanced routing with lazy loading and gu…
✍️ Writing skills By Jeffallan Version v1.0.0 Added 2026-09-07 Updated 2026-09-07 Source ↗
9.0Overall rating
1Views
4Downloads
11.3kStars

Installation

🤖 Install via AI

Copy the prompt below and send it to your AI assistant (e.g. Claude Code) — it will follow the instructions and install automatically.

Install the "angular-architect" skill by following the instructions at https://skill123.me/install/angular-architect.
⌨️ Command line install

Run in your terminal — downloads and installs to ~/.claude/skills/.

curl -fsSL https://skill123.me/install/angular-architect.sh | bash
📦 Download ZIP

Download the zip and extract it into your skills directory (e.g. ~/.claude/skills/), then restart your session.

⬇ Download v1.0.0 · 16 KB
📊 Static rating
9.0/10
Trigger
8.0
Structure
9.3
Workflow
8.8
Content
8.0
Engineering
10.0
Security
10.0

Six-dimension rubric with reviewer rationale.

View scorecard ↓
🛡 Dynamic test
—

Not live-tested yet — this skill is rated on static analysis only.

About this skill

Generates Angular 17+ standalone components, configures advanced routing with lazy loading and guards, implements NgRx state management, applies RxJS patterns, and optimizes bundle performance. Use when building Angular 17+ applications with standalone components or signals, setting up NgRx stores, establishing RxJS reactive patterns, performance tuning, or writing Angular tests for enterprise apps.

Angular Architect

Senior Angular architect specializing in Angular 17+ with standalone components, signals, and enterprise-grade application development.

Documentation

Generates Angular 17+ standalone components, configures advanced routing with lazy loading and guards, implements NgRx state management, applies RxJS patterns, and optimizes bundle performance. Use when building Angular 17+ applications with standalone components or signals, setting up NgRx stores, establishing RxJS reactive patterns, performance tuning, or writing Angular tests for enterprise apps.

Angular Architect

Senior Angular architect specializing in Angular 17+ with standalone components, signals, and enterprise-grade application development.

Core Workflow

1. **Analyze requirements** - Identify components, state needs, routing architecture

2. **Design architecture** - Plan standalone components, signal usage, state flow

3. **Implement features** - Build components with OnPush strategy and reactive patterns

4. **Manage state** - Setup NgRx store, effects, selectors as needed; verify store hydration and action flow with Redux DevTools before proceeding

5. **Optimize** - Apply performance best practices and bundle optimization; run ng build --configuration production to verify bundle size and flag regressions

6. **Test** - Write unit and integration tests with TestBed; verify >85% coverage threshold is met

Reference Guide

Load detailed guidance based on context:

| Topic | Reference | Load When |

|-------|-----------|-----------|

| Components | references/components.md | Standalone components, signals, input/output |

| RxJS | references/rxjs.md | Observables, operators, subjects, error handling |

| NgRx | references/ngrx.md | Store, effects, selectors, entity adapter |

| Routing | references/routing.md | Router config, guards, lazy loading, resolvers |

| Testing | references/testing.md | TestBed, component tests, service tests |

Key Patterns

### Standalone Component with OnPush and Signals


import { ChangeDetectionStrategy, Component, computed, input, output, signal } from '@angular/core';
import { CommonModule } from '@angular/common';

@Component({
  selector: 'app-user-card',
  standalone: true,
  imports: [CommonModule],
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: `
    <div class="user-card">
      <h2>{{ fullName() }}</h2>
      <button (click)="onSelect()">Select</button>
    </div>
  `,
})
export class UserCardComponent {
  firstName = input.required<string>();
  lastName = input.required<string>();
  selected = output<string>();

  fullName = computed(() => `${this.firstName()} ${this.lastName()}`);

  onSelect(): void {
    this.selected.emit(this.fullName());
  }
}

### RxJS Subscription Management with takeUntilDestroyed


import { Component, OnInit, inject } from '@angular/core';
import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
import { UserService } from './user.service';
View full documentation

@Component({ selector: 'app-users', standalone: true, template: ... })

export class UsersComponent implements OnInit {

private userService = inject(UserService);

// DestroyRef is captured at construction time for use in ngOnInit

private destroyRef = inject(DestroyRef);

ngOnInit(): void {

this.userService.getUsers()

.pipe(takeUntilDestroyed(this.destroyRef))

.subscribe({

next: (users) => { /* handle */ },

error: (err) => console.error('Failed to load users', err),

});

}

}



### NgRx Action / Reducer / Selector

// actions

export const loadUsers = createAction('[Users] Load Users');

export const loadUsersSuccess = createAction('[Users] Load Users Success', props<{ users: User[] }>());

export const loadUsersFailure = createAction('[Users] Load Users Failure', props<{ error: string }>());

// reducer

export interface UsersState { users: User[]; loading: boolean; error: string | null; }

const initialState: UsersState = { users: [], loading: false, error: null };

export const usersReducer = createReducer(

initialState,

on(loadUsers, (state) => ({ ...state, loading: true, error: null })),

on(loadUsersSuccess, (state, { users }) => ({ ...state, users, loading: false })),

on(loadUsersFailure, (state, { error }) => ({ ...state, error, loading: false })),

);

// selectors

export const selectUsersState = createFeatureSelector<UsersState>('users');

export const selectAllUsers = createSelector(selectUsersState, (s) => s.users);

export const selectUsersLoading = createSelector(selectUsersState, (s) => s.loading);



## Constraints

### MUST DO
- Use standalone components (Angular 17+ default)
- Use signals for reactive state where appropriate
- Use OnPush change detection strategy
- Use strict TypeScript configuration
- Implement proper error handling in RxJS streams
- Use `trackBy` functions in `*ngFor` loops
- Write tests with >85% coverage
- Follow Angular style guide

### MUST NOT DO
- Use NgModule-based components (except when required for compatibility)
- Forget to unsubscribe from observables (use `takeUntilDestroyed` or `async` pipe)
- Use async operations without proper error handling
- Skip accessibility attributes
- Expose sensitive data in client-side code
- Use `any` type without justification
- Mutate state directly in NgRx
- Skip unit tests for critical logic

## Output Templates

When implementing Angular features, provide:
1. Component file with standalone configuration
2. Service file if business logic is involved
3. State management files if using NgRx
4. Test file with comprehensive test cases
5. Brief explanation of architectural decisions

[Documentation](https://jeffallan.github.io/claude-skills/skills/frontend/angular-architect/)

Score breakdown

Trigger
8.0
What/When with Angular 17/signals/NgRx keywords but no When-Not exclusion
Structure
9.3
154-line SKILL.md, five references with load-when table
Workflow
8.8
Workflow verifies store hydration, production bundle size, and 85 percent test coverage
Content
8.0
Mostly precise imperative code guidance; takeUntilDestroyed example omits DestroyRef import
Engineering
10.0
Valid frontmatter, all reference paths exist
Security
10.0
No scripts, network calls, injection, or sensitive data
Solid Angular 17+ skill with signal/NgRx patterns, MUST/MUST-NOT constraints, and build-coverage verification steps; description lacks When-Not and one RxJS example misses the DestroyRef import.