standards-testing
Prevent common testing anti-patterns that undermine test effectiveness and code quality by ensuring tests verify real behavior rather than mock behavior, keeping production code free from test-only pollution, and enforcing thoughtful mocking strategies. Use this skill when writing or modifying any test files (.test.ts, .test.js, .spec.ts, _test.py, test_*.py, *_test.go, *_spec.rb), when adding mock objects, stubs, spies, or test doubles to test suites, when considering adding methods or properties to production classes that are only called from test code, when setting up complex test fixtures or test data, when tests are failing and you're tempted to adjust mocks to make them pass, when deciding how to isolate code under test from external dependencies, when implementing dependency injection or test seams, during code reviews when reviewing test implementation and mocking strategies, when refactoring tests that have become brittle or hard to maintain, when test setup code is becoming longer than the actual test assertions, or when choosing between integration tests with real components versus unit tests with mocks.
standards-tests
Write focused tests for core user flows and critical paths with clear test names, behavior-focused assertions, mocked external dependencies, and fast execution, deferring edge case testing until explicitly required. Use this skill when creating or modifying test files, writing unit tests, integration tests, or test cases for any feature. Apply when writing test files (test/, __tests__/, spec/, .test.js, .spec.ts, test_*.py), implementing tests for core user workflows, testing critical business logic, mocking external dependencies (databases, APIs, file systems), writing descriptive test names, creating fast-running unit tests, or adding tests at logical completion points of feature development. Use for any task involving test creation, test coverage, test strategy, or test-driven development.
standards-typescript
Apply TypeScript development standards including package manager detection (npm/yarn/pnpm/bun), explicit return types on exports, ESLint/Prettier code quality, one-line JSDoc, and self-documenting code practices. Use this skill when working with TypeScript or JavaScript code, managing dependencies, running tests, or ensuring code quality. Apply when installing packages, writing tests, formatting code, type checking, adding type annotations, organizing imports, or deciding whether to create new files vs. extending existing ones. Use for any TypeScript/JavaScript development task requiring adherence to tooling standards and best practices.
account-identity
Identity and account patterns for src/app/account, including AngularFire Auth integration, signal-first auth state, route guards, and security boundaries; use when touching auth, user/session state, or account UI flows.
angular-ecosystem
Useful Angular libraries, tools, and ecosystem references for Angular development.
angular-fire
Best practices and code patterns for @angular/fire version 20+, integrating Firestore and Auth with Signals and DDD architecture.
angular-material-cdk-animations
Angular Material + CDK + @angular/animations usage patterns aligned with zoneless + signals-first UI and M3 tokens.
architecture-ddd
Domain-Driven Design patterns, concepts, and guidance for software architecture.
capabilitys-layer
Patterns for implementing features under src/app/capabilitys, including presentation/application/domain/integration boundaries, NgRx Signals stores, event-driven communication, and Angular 20 template rules; use when adding or changing a capability.
centralized-state-distributed-behavior
Apply centralized state + distributed behavior to a change: choose the single source of truth, keep writes through explicit commands, and place behavior in the correct owning layer.
change-management
Keep interfaces stable and changes reviewable; includes ADR-lite guidance and deprecation/deletion checks.
cohesion-coupling-review
Review a proposed change for high cohesion/low coupling; recommends the smallest boundary-safe refactor (ownership, minimal public surface, no reach-in imports).
core-design-principles
Apply Black-Tortoise design principles (Occam, cohesion/coupling, tool-first assembly, explicit boundaries, deletion-friendly evolution) to a concrete change request; use as a pre-flight checklist before writing code.
d3-visualization
D3 ecosystem guidance for designing and implementing interactive charts/diagrams in Angular (signals-first, accessible, performant).
dependency-supply-chain
Change discipline for adding/upgrading dependencies; keeps diffs small, avoids unnecessary packages, and preserves deletion-friendly architecture.
design-for-deletion
Apply 'design for deletion' to a change: define the deletion path, avoid cross-context entanglement, and keep shared additions minimal and enduring.
e2e-playwright
Best practices for E2E testing with Playwright, focusing on Angular 20, Firebase Emulators, and Architecture Guards.
eventing-hub
Event-sourcing and EventBus directives for Black-Tortoise, covering structured event schemas, append-before-publish flow, causality/id rules, and safe subscribers; use when touching src/app/eventing, EventBus, or any event handlers/projections.
evolution-maintainability
Apply evolution & maintainability principles to a change: keep interfaces minimal, improve ownership/naming, prefer deletion-friendly refactors, and align with quality gates.
explicit-boundaries
Enforce explicit boundaries in a change: place code in the right layer, keep capability isolation, use ports/adapters and events, and align with architecture gate rules.
firebase-platform
Firebase services, platform guides, and tips for integration with Angular projects.
integration-layer
Infrastructure and integration patterns for src/app/integration, including Firebase/AngularFire usage, Data Connect codegen, repository adapters, DTO mapping, and streaming boundaries; use when touching persistence, external APIs, or platform SDKs.
material-design-3
Material Design 3 (Material You) design system knowledge for modern web and Angular applications. Use when implementing Material Design 3 theming, components, typography, color systems, dynamic color, accessibility patterns, or migrating from Material Design 2. Covers design tokens, theming APIs, and Material You principles.
mcp-codacy
Use the Codacy MCP server (@codacy/codacy-mcp) to run static analysis, retrieve findings, and focus remediation on high-signal issues; use when you need code quality feedback aligned with repo gates (lint, build, architecture:gate).
mcp-context7
Use the Context7 MCP server (@upstash/context7-mcp) to fetch authoritative, version-appropriate library documentation snippets (Angular, NgRx Signals, Firebase, RxJS, Playwright); use when you must confirm API usage, signatures, or best practices without relying on memory.
mcp-playwright
Use the Playwright MCP server (@playwright/mcp) for browser-driven verification, screenshots, console logs, and UI flow validation; use when debugging or validating Angular UI behavior beyond unit tests.
mcp-sequential-thinking
Use the sequential thinking MCP server (@modelcontextprotocol/server-sequential-thinking) to break down complex problems into ordered, testable steps; use when the task requires careful multi-step reasoning, risk reduction, or dependency-sensitive refactors.
mcp-software-planning
Use the Software-planning-mcp MCP server (github:NightTrek/Software-planning-mcp) to generate requirements, designs, task breakdowns, and execution plans for changes in this repo; use when you need structured planning artifacts (requirements/design/tasks) before implementation.
minimal-stable-interface
Apply MSI to a change: minimize exports, define ports/events at boundaries, and keep APIs intention-revealing and deletion-friendly.
quality-gates
Auditing, testing, and architecture-governance instructions for Black-Tortoise, covering when to run `architecture:gate`, update docs/AUDIT-*, ship tests, and satisfy `.github/instructions/64-quality-testing-copilot-instructions.md` before merge.
security-privacy
Pre-flight security & privacy checklist for changes touching identity, data, logging, or external integrations; ensures secrets/PII hygiene and boundary-safe design.
shared-kernel
Shared kernel rules for src/app/shared, defining what can be shared safely (primitives, utilities, UI atoms) and what must not (business logic, cross-context policies); use when adding shared helpers or components.
shell-ui
Shell module patterns for src/app/shell, covering global UI state, layout composition, navigation, theming with Material Design 3 tokens, and zone-less signal-first presentation boundaries; use when changing app chrome or global UI concerns.
side-effect-isolation
Enforce side-effect isolation: identify side effects, move them to boundary adapters/effects, keep Domain pure, and keep UI declarative with signals.
signals-first
Enforce 'Signals first, streams when needed' in a change: keep UI state as signals, isolate streams to boundaries, and convert Observables at the Application/facade boundary.
single-responsibility
Apply SRP to a change request: identify mixed responsibilities, propose the smallest split, and keep interfaces minimal (paired with Occam/tool-first).
tool-first-assembly
Apply Tool-First, Then Assembly during implementation: extract the smallest reusable tool(s) first, then wire them via assembly in outer layers without increasing coupling.
unidirectional-data-flow
Enforce unidirectional data flow in a change: define explicit commands, keep writes in Application, expose state via signals, and isolate side effects at boundaries.
vscode-ext-commands
Guidelines for contributing commands in VS Code extensions. Indicates naming convention, visibility, localization and other relevant attributes, following VS Code extension development guidelines, libraries and good practices
black-tortoise-ui-reviewer
Black-Tortoise UI review and fixes. Use when asked to review UI, layout, or design in this repo. Focus on Angular 20 + standalone components, Material Design 3 tokens, @ngrx/signals state, and DDD layer boundaries. Checks responsiveness, a11y, spacing, and M3 token usage; applies minimal fixes in presentation styles/templates.
webapp-testing
Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.
workflows-orchestration
Workflow orchestration patterns for src/app/workflows, focusing on application-layer use cases, long-running flows, event-driven coordination, and deterministic state transitions; use when implementing multi-step user journeys or cross-capability processes.
workspace-context
Workspace context patterns for src/app/workspace, including workspace lifecycle, stable context signals, workspace switching, and event emission for other modules; use when changing workspace selection, hydration, or context providers.
bun-expert
|
elysiajs-expert
Expert guidance for ElysiaJS web framework development. Use when building REST APIs, GraphQL services, or WebSocket applications with Elysia on Bun. Covers routing, lifecycle hooks, TypeBox validation, Eden type-safe clients, authentication with JWT/Bearer, all official plugins (OpenAPI, CORS, JWT, static, cron, GraphQL, tRPC), testing patterns, and production deployment. Assumes bun-expert skill is active for Bun runtime expertise.
postgresql-expert
|
redis-expert
|
zig-expert
Comprehensive Zig 0.15.2 development expert. Use when writing Zig code, debugging memory issues, designing build systems, implementing comptime metaprogramming, handling errors, or cross-compiling. Automatically activated for any .zig file or build.zig work.
agent-browser
Automates browser interactions for web testing, form filling, screenshots, and data extraction. Use when the user needs to navigate websites, interact with web pages, fill forms, take screenshots, test web applications, or extract information from web pages.
compound-engineering
Compound Engineering workflow for AI-assisted development. Use when planning features, executing work, reviewing code, or codifying learnings. Follows the Plan → Work → Review → Compound loop where each unit of engineering makes subsequent work easier. Triggers on: plan this feature, implement this, review this code, compound learnings, create implementation plan, systematic development.
Page 1442 of 1443 · 72145 results