angular-developer

Generates Angular code and provides architectural guidance. Trigger when creating projects, components, or services, or for best practices on reactivity (signals, linkedSignal, resource), forms, dependency injection, routing, SSR, accessibility (ARIA), animations, styling (component styles, Tailwind CSS), testing, or CLI tooling.

237,82236,1220Updated 6d ago

General

Quick InstallView Source

git clone https://github.com/affaan-m/ECC.git

Overview

About This Skill

--- name: angular-developer description: Generates Angular code and provides architectural guidance. Trigger when creating projects, components, or services, or for best practices on reactivity (signals, linkedSignal, resource), forms, dependency injection, routing, SSR, accessibility (ARIA), animations, styling (component styles, Tailwind CSS), testing, or CLI tooling. metadata: origin: ECC --- # Angular Developer Guidelines ## When to Activate - Working in any Angular project or codebase - Creating or scaffolding a new Angular project, application, or library - Generating components, services, directives, pipes, guards, or resolvers - Implementing reactivity with Angular Signals, `linkedSignal`, or `resource` - Working with Angular forms (signal forms, reactive forms, or template-driven) - Setting up dependency injection, routing, lazy loading, or route guards - Adding accessibility (ARIA), animations, or component styling - Writing or debugging Angular-specific tests (unit, component harness, E2E) - Configuring Angular CLI tooling or the Angular MCP server 1. Always analyze the project's Angular version before providing guidance, as best practices and available features can vary significantly between versions. If creating a new project with Angular CLI, do not specify a version unless prompted by the user. 2. When generating code, follow Angular's style guide and best practices for maintainability and performance. Use the Angular CLI for scaffolding components, services, directives, pipes, and routes to ensure consistency. 3. Once you finish generating code, run `ng build` to ensure there are no build errors. If there are errors, analyze the error messages and fix them before proceeding. Do not skip this step, as it is critical for ensuring the generated code is correct and functional. ## Creating New Projects If no guidelines are provided by the user, use these defaults when creating a new Angular project: 1. Use the latest stable version of Angular unless the user specifies otherwise. 2. Prefer Signal Forms for new projects only when the target Angular version supports them. [Find out more](references/signal-forms.md). **Execution Rules for `ng new`:** When asked to create a new Angular project, you must determine the correct execution command by following these strict steps: **Step 1: Check for an explicit user version.** - **IF** the user requests a specific version (e.g., Angular 15), bypass local installations and strictly use `npx`. - **Command:** `npx @angular/cli@<requested_version> new <project-name>` **Step 2: Check for an existing Angular installation.** - **IF** no specific version is requested, run `ng version` in the terminal to check if the Angular CLI is already installed on the system. - **IF** the command succeeds and returns an installed version, use the local/global installation directly. - **Command:** `ng new <project-name>` **Step 3: Fallback to Latest.** - **IF** no specific version is requested AND the `ng version` command fails (indicating no Angular installation exists), you must use `npx` to fetch the latest version. - **Command:** `npx @angular/cli@latest new <project-name>` ## Components When working with Angular components, consult the following references based on the task: - **Fundamentals**: Anatomy, metadata, core concepts, and template control flow (@if, @for, @switch). Read [components.md](references/components.md) - **Inputs**: Signal-based inputs, transforms, and model inputs. Read [inputs.md](references/inputs.md) - **Outputs**: Signal-based outputs and custom event best practices. Read [outputs.md](references/outputs.md) - **Host Elements**: Host bindings and attribute injection. Read [host-elements.md](references/host-elements.md) If you require deeper documentation not found in the references above, read the documentation at `https://angular.dev/guide/components`. ## Reactivity and Data Management When managing state and data reactivity, use Angular Signals and consult the following references: - **Signals Overview**: Core signal concepts (`signal`, `computed`), reactive contexts, and `untracked`. Read [signals-overview.md](references/signals-overview.md) - **Dependent State (`linkedSignal`)**: Creating writable state linked to source signals. Read [linked-signal.md](references/linked-signal.md) - **Async Reactivity (`resource`)**: Fetching asynchronous data directly into signal state. Read [resource.md](references/resource.md) - **Side Effects (`effect`)**: Logging, third-party DOM manipulation (`afterRenderEffect`), and when NOT to use effects. Read [effects.md](references/effects.md) ## Forms In most cases for new apps, **prefer signal forms**. When making a forms decision, analyze the project and consider the following guidelines: - If the application version supports Signal Forms and this is a new form, **prefer signal forms**. - For older applications or existing forms, match the application's current form strategy. - **Signal Forms**: Use signals for form state management. Read [signal-forms.md](references/signal-forms.md) - **Template-driven forms**: Use for simple forms. Read [template-driven-forms.md](references/template-driven-forms.md) - **Reactive forms**: Use for complex forms. Read [reactive-forms.md](references/reactive-forms.md) ## Dependency Injection When implementing dependency injection in Angular, follow these guidelines: - **Fundamentals**: Overview of Dependency Injection, services, and the `inject()` function. Read [di-fundamentals.md](references/di-fundamentals.md) - **Creating and Using Services**: Creating services, the `providedIn: 'root'` option, and injecting into components or other services. Read [creating-services.md](references/creating-services.md) - **Defining Dependency Providers**: Automatic vs manual provision, `InjectionToken`, `useClass`, `useValue`, `useFactory`, and scopes. Read [defining-providers.md](references/defining-providers.md) - **Injection Context**: Where `inject()` is allowed, `runInInjectionContext`, and `assertInInjectionContext`. Read [injection-context.md](references/injection-context.md) - **Hierarchical Injectors**: The `EnvironmentInjector` vs `ElementInjector`, resolution rules, modifiers (`optional`, `skipSelf`), and `providers` vs `viewProviders`. Read [hierarchical-injectors.md](references/hierarchical-injectors.md) ## Angular Aria When building accessible custom components for any of the following patterns: Accordion, Listbox, Combobox, Menu, Tabs, Toolbar, Tree, Grid, consult the following reference: - **Angular Aria Components**: Building headless, accessible components (Accordion, Listbox, Combobox, Menu, Tabs, Toolbar, Tree, Grid) and styling ARIA attributes. Read [angular-aria.md](references/angular-aria.md) ## Routing When implementing navigation in Angular, consult the following references: - **Define Routes**: URL paths, static vs dynamic segments, wildcards, and redirects. Read [define-routes.md](references/define-routes.md) - **Route Loading Strategies**: Eager vs lazy loading, and context-aware loading. Read [loading-strategies.md](references/loading-strategies.md) - **Show Routes with Outlets**: Using `<router-outlet>`, nested outlets, and named outlets. Read [show-routes-with-outlets.md](references/show-routes-with-outlets.md) - **Navigate to Routes**: Declarative navigation with `RouterLink` and programmatic navigation with `Router`. Read [navigate-to-routes.md](references/navigate-to-routes.md) - **Control Route Access with Guards**: Implementing `CanActivate`, `CanMatch`, and other guards for security. Read [route-guards.md](references/route-guards.md) - **Data Resolvers**: Pre-fetching data before route activation with `ResolveFn`. Read [data-resolvers.md](references/data-resolvers.md) - **Router Lifecycle and Events**: Chronological order of navigation events and debugging. Read [router-lifecycle.md](references/router-lifecycle.md) - **Rendering Strategies**: CSR, SSG (Prerendering), and SSR with hydration. Read [rendering-strategies.md](references/rendering-strategies.md) - **Route Transition Animations**: Enabling and customizing the View Transitions API. Read [route-animations.md](references/route-animations.md) If you require deeper documentation or more context, visit the [official Angular Routing guide](https://angular.dev/guide/routing). ## Styling and Animations When implementing styling and animations in Angular, consult the following references: - **Using Tailwind CSS with Angular**: Integrating Tailwind CSS into Angular projects. Read [tailwind-css.md](references/tailwind-css.md) - **Angular Animations**: Using native CSS (recommended) or the legacy DSL for dynamic effects. Read [angular-animations.md](references/angular-animations.md) - **Styling components**: Best practices for component styles and encapsulation. Read [component-styling.md](references/component-styling.md) ## Testing When writing or updating tests, consult the following references based on the task: - **Fundamentals**: Best practices for unit testing, async patterns, and `TestBed`. Read [testing-fundamentals.md](references/testing-fundamentals.md) - **Component Harnesses**: Standard patterns for robust component interaction. Read [component-harnesses.md](references/component-harnesses.md) - **Router Testing**: Using `RouterTestingHarness` for reliable navigation tests. Read [router-testing.md](references/router-testing.md) - **End-to-End (E2E) Testing**: Best practices for E2E tests with Cypress or Playwright. Read [e2e-testing.md](references/e2e-testing.md) ## Tooling When working with Angular tooling, consult the following references: - **Angular CLI**: Creating applications, generating code (components, routes, services), serving, and building. Read [cli.md](references/cli.md) - **Angular MCP Server**: Available tools, configuration, and experimental features. Read [mcp.md](references/mcp.md) ## Anti-Patterns - Using `null` or `undefined` as initial signal form field values — use `''`, `0`, or `[]` instead - Accessing form field state flags without calling the field first: `form.field.valid()` — use `form.field().valid()` - Starting new forms with older form APIs when the target Angular version supports Signal Forms - Setting `min`, `max`, `value`, `disabled`, or `readonly` HTML attributes on `[formField]` inputs — define these as schema rules instead - Calling `inject()` outside an injection context — use `runInInjectionContext` when needed - Using `effect()` for derived state that should use `computed()` - Referencing `$parent.$index` in nested `@for` loops — Angular does not support `$parent`; use `let outerIdx = $index` instead ## Related Skills - `tdd-workflow` — test-driven development workflow applicable to Angular components and services - `security-review` — security checklist for web applications including Angular-specific concerns - `frontend-patterns` — general frontend patterns for context on React/Next.js approaches

How to Use

[{"step":"Identify the Angular artifact you need","action":"Specify whether you need a component, service, module, directive, pipe, or utility function. Include the Angular version if relevant.","tip":"For new features, start with a component. For shared logic, use a service. For global state, consider signals or a service with RxJS."},{"step":"Define the requirements and constraints","action":"Provide details about the feature, including: 1) Inputs/outputs, 2) Dependencies, 3) Performance requirements, 4) Styling approach (component styles vs Tailwind), 5) Testing strategy, 6) Accessibility needs.","tip":"Be specific about edge cases (e.g., 'handle concurrent updates to the same item'). Mention if you need SSR compatibility."},{"step":"Generate the code with context","action":"Use the prompt template, filling in [PLACEHOLDERS] with your specific requirements. For complex features, break it into smaller parts (e.g., generate the service first, then the component).","tip":"For forms, specify if you need template-driven, reactive forms, or standalone signals. For routing, mention if you need lazy loading or route guards."},{"step":"Review and integrate","action":"Check the generated code against your requirements. Look for: 1) Proper error handling, 2) Type safety, 3) Performance optimizations, 4) Documentation, 5) Testability. Integrate into your project and run tests.","tip":"Use Angular CLI commands like `ng generate component`, `ng generate service`, or `ng generate module` to scaffold the generated code. For standalone components, add `standalone: true` to the component decorator."},{"step":"Iterate and optimize","action":"Test the component/service in your application. Identify performance bottlenecks or UX issues. Use Angular DevTools to profile change detection and memory usage. Refine the implementation based on feedback.","tip":"For animations, use Angular’s `@angular/animations` package. For SSR, ensure your code is compatible with server-side rendering (avoid `window` or `document` in component code)."}]

Setup & Installation

Quick Install

No install command available. Check the GitHub repository for manual installation instructions.

Alternative Install (Git Clone)

git clone https://github.com/affaan-m/ECC/tree/main/skills/angular-developer

Requirements

Claude Code or compatible AI agent

Quick Start Guide

Install the Skill

Copy the install command above and run it in your terminal.

Open Your AI Agent

Launch Claude Code, Cursor, or your preferred AI coding agent.

Try It Out

Use the prompt template or examples below to test the skill.

Customize

Adapt the skill to your specific use case and workflow.

Usage Examples

Prompt Template

Generate a production-ready Angular [COMPONENT/SERVICE/MODULE] for [PROJECT NAME] that implements [SPECIFIC FEATURE]. Use [Angular version] and follow best practices for [REACTIVITY FORM (signals, linkedSignal, resource)/FORMS/ROUTING/SSR/ACCESSIBILITY/ANIMATIONS/STYLING (component styles/Tailwind CSS)/TESTING/CLI TOOLING]. Include proper error handling, TypeScript interfaces, and documentation comments. Provide the code in a [STANDALONE/MODULE] format with [DEPENDENCY INJECTION] where applicable. Add a brief explanation of key architectural decisions.

Example Output

Here’s a production-ready Angular service for a fictional e-commerce platform called **ShopEase** that implements a `CartService` using Angular Signals for reactivity and dependency injection. The service includes methods for adding/removing items, calculating totals, and handling edge cases like concurrent updates. It’s designed as a standalone service (Angular 17+) with proper error handling and TypeScript interfaces.

```typescript
// cart.service.ts
import { Injectable, signal, computed } from '@angular/core';
import { Product } from '../models/product.model';
import { CartItem } from '../models/cart-item.model';

export interface CartState {
  items: CartItem[];
  loading: boolean;
  error: string | null;
}

@Injectable({ providedIn: 'root' })
export class CartService {
  private state = signal<CartState>({ 
    items: [], 
    loading: false, 
    error: null 
  });

  // Computed signal for derived data
  public totalItems = computed(() => 
    this.state().items.reduce((sum, item) => sum + item.quantity, 0)
  );

  public subtotal = computed(() => 
    this.state().items.reduce((sum, item) => 
      sum + (item.product.price * item.quantity), 0
    )
  );

  public tax = computed(() => this.subtotal() * 0.08);
  public total = computed(() => this.subtotal() + this.tax());

  // Add item to cart (handles duplicates)
  addItem(product: Product, quantity: number = 1): void {
    this.state.update(current => {
      const existingItem = current.items.find(item => item.product.id === product.id);
      if (existingItem) {
        return {
          ...current,
          items: current.items.map(item => 
            item.product.id === product.id 
              ? { ...item, quantity: item.quantity + quantity }
              : item
          )
        };
      }
      return { ...current, items: [...current.items, { product, quantity }] };
    });
  }

  // Remove item completely
  removeItem(productId: string): void {
    this.state.update(current => ({
      ...current,
      items: current.items.filter(item => item.product.id !== productId)
    }));
  }

  // Update quantity (with validation)
  updateQuantity(productId: string, quantity: number): void {
    if (quantity <= 0) {
      this.removeItem(productId);
      return;
    }
    this.state.update(current => ({
      ...current,
      items: current.items.map(item => 
        item.product.id === productId 
          ? { ...item, quantity }
          : item
      )
    }));
  }

  // Clear entire cart
  clearCart(): void {
    this.state.set({ items: [], loading: false, error: null });
  }

  // Simulate async operation (e.g., API call)
  async syncWithBackend(): Promise<void> {
    this.state.set({ ...this.state(), loading: true, error: null });
    try {
      // In a real app, this would be an HTTP call
      await new Promise(resolve => setTimeout(resolve, 500));
      this.state.set({ ...this.state(), loading: false });
    } catch (error) {
      this.state.set({ 
        ...this.state(), 
        loading: false,
        error: 'Failed to sync cart with backend' 
      });
    }
  }
}
```

**Key Architectural Decisions:**
1. **Signals for Reactivity**: Used Angular’s new `signal` and `computed` for fine-grained reactivity, replacing traditional RxJS for this simple state management.
2. **Immutable Updates**: State updates are immutable to prevent side effects and ensure change detection works correctly.
3. **Type Safety**: Strong typing with interfaces for the cart state and items ensures compile-time safety.
4. **Error Handling**: Graceful error handling in async operations with loading states.
5. **Standalone Service**: Designed as a standalone service (Angular 17+) for better tree-shaking and lazy loading.

**Testing Recommendations:**
- Unit tests for each method using Jest
- Test edge cases like concurrent updates
- Mock the backend sync operation
- Verify computed signals update correctly

**Next Steps:**
1. Create a `CartComponent` to display the cart UI
2. Implement a `CartItemComponent` for individual items
3. Add animations for adding/removing items
4. Integrate with a real backend API
5. Add accessibility attributes (ARIA) for screen readers

Source repo

affaan-m/ecc

skills-collection

Find the right skills for your stack

Take a free 3-minute scan and get personalized AI skill recommendations.

Take free scan