vp-implement-module
Standardizes the creation of new NestJS domain modules in the VoxPopuli backend.
Install
mkdir -p .claude/skills/vp-implement-module && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/13276" && unzip -o skill.zip -d .claude/skills/vp-implement-module && rm skill.zipInstalls to .claude/skills/vp-implement-module
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Use when creating a new NestJS module in the VoxPopuli backend - covers service, module, spec file, shared types, and AppModule wiring following project conventionsKey capabilities
- →Create a new NestJS module structure
- →Implement an injectable service with JSDoc and strict TypeScript
- →Configure a NestJS module with imports, providers, and exports
- →Write Jest tests for the service using `Test.createTestingModule()`
- →Wire the new module into `apps/api/src/app/app.module.ts`
- →Add new interfaces to `libs/shared-types/src/lib/shared-types.ts`
How it works
The skill follows a predefined pattern to generate a new NestJS module, including its service, module, and test files, and integrates it into the main application module. It adheres to project-specific conventions for dependency injection and external calls.
Inputs & outputs
When to use vp-implement-module
- →Creating new domain modules
- →Implementing backend services
- →Adding new API features
About this skill
Implement NestJS Module (VoxPopuli)
Overview
Pattern for creating a new NestJS module in VoxPopuli. Every module follows the same structure: injectable service, NestJS module with exports, Jest spec file, and wiring into AppModule.
When to Use
- Adding a new domain module to
apps/api/src/ - Implementing a Linear epic that introduces a new service
- Not for: modifying existing modules, frontend work, or eval harness
Module Structure
apps/api/src/{module-name}/
{module-name}.service.ts # @Injectable() service
{module-name}.module.ts # NestJS module
{module-name}.service.spec.ts # Jest tests
{module-name}.controller.ts # Only if HTTP endpoints needed
Implementation Checklist
- Shared types first -- Add any new interfaces to
libs/shared-types/src/lib/shared-types.tsand re-export fromindex.ts - Service --
@Injectable(), constructor injection for dependencies, JSDoc on public methods, strict TypeScript (noany) - Module -- Import dependencies, provide service, export service
- Tests -- Jest with
@swc/jest, useTest.createTestingModule(), mock all external dependencies (HTTP, LLM, cache) - Wire up -- Import module in
apps/api/src/app/app.module.ts - Verify --
npx nx test apiandnpx nx build api
Key Conventions
| Convention | Rule |
|---|---|
| DI | Constructor injection only, no direct imports between modules |
| External calls | All go through CacheService.getOrSet<T>() |
| LLM access | Via LlmService.getModel(), never instantiate providers directly |
| Token budgets | Via LlmService.getMaxContextTokens(), not hardcoded |
| SSE events | Only thought, action, observation, answer, error types |
| Test framework | Jest (not Vitest), mocks via jest.fn() |
Common Mistakes
- Importing between NestJS modules directly instead of using DI
- Forgetting to export service from module (other modules can't inject it)
- Using
ConfigModuleimport in module -- it's already global - Hitting real APIs in tests -- always mock HTTP and LLM calls
- Using
vi.fn()(Vitest) in API tests -- the API project uses Jest, usejest.fn() - Not mocking LLM providers in test files that transitively import
LlmServiceorAgentService-- Jest can't resolve@langchain/*ESM packages. Add these mocks at the top of spec files:jest.mock('../llm/providers/groq.provider', () => ({ GroqProvider: jest.fn() })); jest.mock('../llm/providers/claude.provider', () => ({ ClaudeProvider: jest.fn() })); jest.mock('../llm/providers/mistral.provider', () => ({ MistralProvider: jest.fn() }));
When not to use it
- →When modifying existing modules
- →When performing frontend work
- →When working on an evaluation harness
Limitations
- →It is not for modifying existing modules.
- →It is not for frontend work.
- →It is not for evaluation harness tasks.
How it compares
This skill automates the creation of a NestJS module following specific project conventions, ensuring consistency and proper integration within the VoxPopuli backend.
Compared to similar skills
vp-implement-module side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| vp-implement-module (this skill) | 0 | 4mo | No flags | Intermediate |
| telegram-mini-app | 62 | 6mo | Review | Advanced |
| stripe-integration | 48 | 2mo | No flags | Advanced |
| nodejs-backend-patterns | 12 | 2mo | No flags | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
You might also like
telegram-mini-app
davila7
Expert in building Telegram Mini Apps (TWA) - web apps that run inside Telegram with native-like experience. Covers the TON ecosystem, Telegram Web App API, payments, user authentication, and building viral mini apps that monetize. Use when: telegram mini app, TWA, telegram web app, TON app, mini app.
stripe-integration
wshobson
Implement Stripe payment processing for robust, PCI-compliant payment flows including checkout, subscriptions, and webhooks. Use when integrating Stripe payments, building subscription systems, or implementing secure checkout flows.
nodejs-backend-patterns
wshobson
Build production-ready Node.js backend services with Express/Fastify, implementing middleware patterns, error handling, authentication, database integration, and API design best practices. Use when creating Node.js servers, REST APIs, GraphQL backends, or microservices architectures.
agent-dev-backend-api
ruvnet
Agent skill for dev-backend-api - invoke with $agent-dev-backend-api
shopify-apps
alinaqi
Shopify app development - Remix, Admin API, checkout extensions
ccxt-typescript
ccxt
CCXT cryptocurrency exchange library for TypeScript and JavaScript developers (Node.js and browser). Covers both REST API (standard) and WebSocket API (real-time). Helps install CCXT, connect to exchanges, fetch market data, place orders, stream live tickers/orderbooks, handle authentication, and manage errors. Use when working with crypto exchanges in TypeScript/JavaScript projects, trading bots, arbitrage systems, or portfolio management tools. Includes both REST and WebSocket examples.