software-development

Use this agent when the task involves server-side implementation, business logic, API development, database integration, or backend architecture in a TypeScript/Node.js codebase. Triggers on requests to implement services, controllers, middleware, data models, repositories, or any server-side concern. Also triggers for refactoring backend code to improve structure, typing, error handling, or adherence to SOLID principles. <example> Context: User is building an e-commerce platform and needs to handle payments. user: "implement the payment processing service" assistant: "I'll use the backend-software-developer-agent to implement the payment processing service with proper error handling, clean architecture, and strict TypeScript typing." <commentary> "Implement the payment processing service" is a clear backend business logic task. The agent handles service-layer implementation following SOLID principles and clean architecture. </commentary> </example> <example> Context: User needs to protect routes in their Node.js API. user: "create the user authentication middleware" assistant: "I'll use the backend-software-developer-agent to create the authentication middleware with proper type guards, custom error classes, and single-responsibility design." <commentary> Middleware is server-side infrastructure. The agent applies strict typing and the Single Responsibility Principle to produce a focused, testable middleware function. </commentary> </example> <example> Context: User is designing the data layer for an order management system. user: "design the data model for orders" assistant: "I'll use the backend-software-developer-agent to design the order data model — defining domain entities, value objects, and repository interfaces following clean architecture boundaries." <commentary> Data modeling is a backend architecture concern. The agent separates domain entities from persistence concerns and enforces strict typing on all interfaces. </commentary> </example> <example> Context: User has a service with mixed concerns and poor cohesion. user: "refactor this service to follow SOLID principles" assistant: "I'll use the backend-software-developer-agent to audit the service against SOLID principles and refactor it — splitting responsibilities, introducing interfaces, and applying the appropriate design patterns." <commentary> SOLID refactoring is a core competency of this agent. It applies the solid-principles and design-patterns skills to produce clean, maintainable backend code. </commentary> </example> <example> Context: User's API endpoints are throwing unhandled exceptions in production. user: "add error handling to the API endpoints" assistant: "I'll use the backend-software-developer-agent to implement structured error handling — defining custom error classes, adding error boundaries, and ensuring no errors are swallowed silently." <commentary> Error handling is a backend concern requiring domain-specific custom error hierarchies and proper propagation patterns. The agent applies the error-handling skill. </commentary> </example>

Use this agent when the task involves building, modifying, or reviewing frontend UI code — React components, Tailwind CSS styling, shadcn/ui or Radix UI primitives, responsive layouts, accessibility improvements, browser APIs, or frontend architecture decisions. Triggers on requests to create or fix components, apply styling, implement forms, handle UI state, wire up component libraries, or improve frontend performance and accessibility. <example> Context: User needs a new dashboard page built as a React component. user: "Build the dashboard component with a stats grid and recent activity feed" assistant: "I'll use the frontend-software-developer-agent to build the dashboard — composing a stats grid and activity feed with proper TypeScript types, Tailwind layout, and accessibility markup." <commentary> "Build the dashboard component" is a direct UI component construction request. The frontend agent owns all React component authoring, layout, and styling work. </commentary> </example> <example> Context: User wants the navigation bar styled with Tailwind. user: "Style the navigation with Tailwind — it should be responsive and collapse on mobile" assistant: "I'll use the frontend-software-developer-agent to implement the responsive navigation with Tailwind utility classes and a mobile-collapse behaviour." <commentary> CSS/styling with Tailwind and responsive design are core frontend concerns. The agent handles the full responsive implementation. </commentary> </example> <example> Context: User wants a reusable, validated form component. user: "Create a reusable form with validation for the signup page" assistant: "I'll use the frontend-software-developer-agent to build a controlled form component with typed props, field-level validation, and error state handling." <commentary> React form patterns — controlled components, validation, typed props — are squarely in the frontend agent's domain. </commentary> </example> <example> Context: User reports a layout breaking on small screens. user: "Fix the responsive layout on mobile — the sidebar overlaps the content" assistant: "I'll use the frontend-software-developer-agent to diagnose and fix the responsive layout issue, adjusting Tailwind breakpoint classes and flex/grid configuration." <commentary> Responsive layout debugging is a frontend task. The agent investigates the component tree and Tailwind classes to resolve the overlap. </commentary> </example> <example> Context: User wants to add a modal dialog using the shadcn/ui library. user: "Add a dialog using shadcn for the delete confirmation flow" assistant: "I'll use the frontend-software-developer-agent to wire up a shadcn Dialog component with the correct Radix UI accessibility primitives and controlled open state." <commentary> shadcn/ui and Radix UI component integration is a primary frontend agent use case. </commentary> </example>

Use this agent when the task involves creating, extending, or running tests for backend or frontend code. Triggers on requests to write unit tests, integration tests, add test coverage, fix failing tests, or refactor test suites. Also triggers when the user explicitly asks to create e2e tests. The agent collaborates with frontend-software-developer-agent and backend-software-developer-agent by testing the code they produce. <example> Context: User just implemented a payment service with the backend agent. user: "write tests for the payment service" assistant: "I'll use the tester-agent to create unit and integration tests for the payment service, covering all public methods, error paths, and edge cases." <commentary> "Write tests for the payment service" is a direct test creation request. The tester agent owns all test authoring — it reads the implementation, identifies testable behavior, and produces tests following Given/When/Then structure. </commentary> </example> <example> Context: User has a React component built by the frontend agent. user: "add tests for the UserProfile component" assistant: "I'll use the tester-agent to write component tests for UserProfile — covering rendering, user interactions, and edge cases with proper mocking of dependencies." <commentary> Component testing is a tester agent concern. It tests the component's behavior, not its implementation details, using the appropriate framework (Vitest or Jest) detected from the project. </commentary> </example> <example> Context: User notices tests are failing after a refactor. user: "fix the broken tests in the order module" assistant: "I'll use the tester-agent to diagnose and fix the failing tests in the order module — updating assertions and mocks to match the refactored implementation." <commentary> Fixing broken tests requires understanding both the test intent and the new implementation. The tester agent reads both, identifies mismatches, and updates tests while preserving coverage. </commentary> </example> <example> Context: User wants to ensure a critical flow works end-to-end. user: "create e2e tests for the checkout flow" assistant: "I'll use the tester-agent to create e2e tests for the checkout flow — covering the full user journey from cart to payment confirmation." <commentary> E2e tests are only created when the user explicitly requests them. The tester agent sets up the test with proper setup/teardown and realistic test data. </commentary> </example> <example> Context: User has multiple similar validation scenarios to test. user: "there are a lot of similar cases, use parameterized tests" assistant: "I'll use the tester-agent to refactor the test suite using describe.each and it.each for the repeated validation scenarios." <commentary> Parameterized testing with it.each/describe.each is a core tester agent pattern for reducing duplication in test suites with similar cases. </commentary> </example>

REST API design conventions and best practices for TypeScript/Node.js. Loaded by backend-software-developer-agent when creating endpoints, designing request/response schemas, or structuring API routes.

Tailwind CSS conventions, Radix UI primitives, and shadcn/ui component patterns for modern React frontends. Loaded by frontend-software-developer-agent when styling components, implementing responsive design, or using shadcn/ui.

Database access patterns for TypeScript/Node.js with Prisma, Drizzle, and Knex. Loaded by backend-software-developer-agent when implementing data access layers, writing queries, or designing database schemas.

Design patterns reference for TypeScript backend development — GoF patterns, DDD aggregates, and Clean Architecture layers. Loaded by backend-software-developer-agent when designing services, implementing complex business logic, or structuring application architecture.

Error handling patterns for TypeScript applications — custom errors, Result types, React error boundaries, and API error responses. Loaded by both backend-software-developer-agent and frontend-software-developer-agent when implementing error handling strategies.

Jest testing patterns and conventions for TypeScript projects. This skill should be used when the project uses Jest as its test framework — detected via jest in package.json dependencies, jest.config.ts, jest.config.js, or a jest field in package.json. Loaded by the tester-agent when creating or modifying tests in a Jest project.

Structured logging and observability patterns for TypeScript/Node.js backends. Loaded by backend-software-developer-agent when implementing logging, error tracking, or monitoring in server-side applications.

Performance optimization patterns for both backend (Node.js) and frontend (React) TypeScript applications. Loaded by backend-software-developer-agent and frontend-software-developer-agent when optimizing application performance.

React component patterns, hooks, and state management best practices for TypeScript. Loaded by frontend-software-developer-agent when building UI components, managing state, or structuring React applications.

Security best practices for TypeScript full-stack applications — input validation, authentication patterns, and common vulnerability prevention. Loaded by both backend-software-developer-agent and frontend-software-developer-agent when handling user input, authentication, or data sanitization.

SOLID principles reference for TypeScript/Node.js backend development. Loaded by backend-software-developer-agent when implementing business logic, designing services, or refactoring code for better maintainability.

Strict TypeScript typing patterns and anti-patterns for full-stack development. Loaded by both backend-software-developer-agent and frontend-software-developer-agent to enforce type safety and eliminate any/undefined usage.

Vitest testing patterns and conventions for TypeScript projects. This skill should be used when the project uses Vitest as its test framework — detected via vitest in package.json dependencies, vitest.config.ts, or vite.config.ts with test configuration. Loaded by the tester-agent when creating or modifying tests in a Vitest project.