ai-base

Refines and improves user prompts interactively before execution. Use when a task is vague, underspecified, or complex — asks clarifying questions about scope, deliverables, and constraints, then produces a polished, detailed prompt. Never writes code itself.

Performs thorough code reviews covering quality, security, performance, and best practices. Use when asked to review a pull request, audit code changes, check for security vulnerabilities, assess code quality, or provide feedback on a diff. Outputs structured feedback with severity levels and actionable suggestions.

Iterative implementation workflow for requirements. Use this skill when asked to implement a feature, user story, requirement, or change request. Guides through 5 phases: requirement review, implementation planning, sub-agent-driven implementation (code, tests, documentation), code review with rework loop, and final summary. Never commits code — the user always commits manually.

Refactors existing code to improve structure, readability, and maintainability without changing behavior. Use when asked to clean up code, reduce duplication, apply SOLID principles, or address code smells (long methods, tight coupling, poor naming). Always verifies existing tests pass before and after changes.

Applies Angular best practices for building the UI/presentation layer — components, templates, routing, forms, validation, HTTP consumption, interceptors, guards, and error handling. Use when creating components, configuring the router, building reactive or template-driven forms, wiring HttpClient and interceptors, adding route guards, handling client-side errors, or structuring an Angular app. For dependency injection, the provide/config pattern, and modern TypeScript idioms, use angular-fundamentals.

Use when asked to implement, extend, or change a feature, user story, requirement, or bug fix in an Angular / TypeScript project — any task that produces or modifies Angular production code, tests, or documentation. Use when an Angular change request arrives, before writing any code.

Applies modern Angular fundamentals — dependency injection, the typed-configuration (provide) pattern, environment/runtime configuration, and modern TypeScript/Angular idioms. Use when registering providers in any Angular app or library, defining InjectionToken-based configuration, choosing a provider scope, setting up environments and runtime config, or applying standalone APIs, signals, inject(), strict null checks, and DestroyRef-based teardown.

Generates complete Angular libraries / client SDKs with DI support, a provideXxx() entry point, typed HttpClient services, typed configuration, and typed errors. Use when asked to create an Angular library, build an Angular client SDK, wrap a REST API in a typed Angular service, or generate a publishable ng-packagr library. Invokes angular-tsdoc for documentation and angular-tester for tests.

Performs structured code reviews on Angular 17+ projects. Reviews either uncommitted working-tree changes or committed changes on the current feature branch (vs. main). Produces a Markdown report under docs/reviews/ with severity-tagged findings ([Critical|Major|Minor|Suggestion|Nitpick][Security|Performance|Architecture|Code-Quality|Tests|Angular-Idioms]) and fix suggestions. Must NOT activate on generic "review my code" requests; other-language reviewers must not be hijacked.

Applies Angular best practices for reactive data access and client-side state management. Use when designing a store or state service, choosing between signals, RxJS, and NgRx, modeling state shape, writing selectors/derived state, optimizing change detection, handling optimistic updates and concurrency, persisting/hydrating state, or troubleshooting over-fetching and re-render performance.

Writes, executes, and completes unit tests for Angular/TypeScript code using Jasmine + Karma (or Jest), TestBed, and spies. Uses a second agent to identify missing test cases. Use when asked to create Angular tests or improve test coverage.

Adds and reviews TSDoc/JSDoc documentation comments on Angular/TypeScript code following TSDoc and Compodoc conventions. Use when writing or reviewing TypeScript that includes public APIs, exported library symbols, complex logic, or when documentation is missing or insufficient. Covers the summary line, @param, @returns, @throws, @remarks, @example, {@link}, and {@inheritDoc}.

Manages npm packages in Angular projects and workspaces. Use when adding, removing, or updating npm dependencies or versions. Enforces the npm/ng CLI for package operations, prefers `ng add` for Angular-aware packages and `ng update` for framework upgrades, and provides version verification workflows. Handles npm install/uninstall, npm outdated, ng add, ng update, and lockfile-consistent installs.

Entry point and router for Angular and TypeScript front-end work — directs you to the right specialized Angular skill. Use when a request mentions Angular in general but the specific tool is not obvious, or to get an overview of the available Angular skills. Routes to knowledge skills (angular-fundamentals, angular-components, angular-state, angular-tsdoc) and workflow skills (angular-library-builder, angular-tester, angular-reviewer, angular-package-manager). When the matching skill is already clear, invoke that skill directly instead.

Performs structured code reviews on .NET 10+ projects. Reviews either uncommitted working-tree changes or committed changes on the current feature branch (vs. main). Produces a Markdown report under docs/reviews/ with severity-tagged findings ([Critical|Major|Minor|Suggestion|Nitpick][Security|Performance|Architecture|Code-Quality|Tests|.NET-Idioms]) and fix suggestions. Must NOT activate on generic "review my code" requests; other-language reviewers must not be hijacked.

Writes and improves JUnit 5 unit tests for Java projects. Use when asked to create unit tests, write parameterized/data-driven tests, improve test coverage, set up mocking with Mockito, or follow testing best practices with JUnit Jupiter. Covers test structure, assertions, @ParameterizedTest, @ValueSource, @CsvSource, and @MethodSource.

Use when creating new skills, editing existing skills, or verifying skills work before deployment

You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

Guidelines for creating high-quality Agent Skills for GitHub Copilot

Scaffolds a new Spring Boot Java project from Spring Initializr with PostgreSQL, Redis, MongoDB, Docker Compose, and OpenAPI/Swagger support. Use when asked to create a new Java project, bootstrap a Spring Boot app, generate a project skeleton, or set up a Java microservice from scratch.

Adds and reviews Javadoc documentation comments following Java best practices. Use when writing or reviewing Java code that needs Javadoc for public APIs, complex logic, or when documentation is missing. Covers @param, @return, @throws, @see, {@code}, {@inheritDoc}, and all standard Javadoc tags.

Best practices for building Spring Boot applications in Java. Use when developing REST APIs, configuring dependency injection, setting up JPA repositories, implementing security with Spring Security, writing integration tests with @SpringBootTest, or structuring a Spring Boot project. Covers controllers, services, configuration, profiles, and testing.

Best practices for writing JavaScript and TypeScript tests with Jest. Use when asked to write unit tests, improve test coverage, set up mocking, test async code, or test React components with Testing Library. Covers test structure, mock strategies, snapshot testing, and common Jest matchers.

RxJS reactive programming patterns and best practices for TypeScript and Angular projects. Use when working with Observables, Subjects, operators (switchMap, combineLatest, etc.), subscription management, error handling with catchError/retry, or performance optimization (shareReplay, debounce). Includes Angular-specific patterns like async pipe and takeUntil.