Skip to main content
skill CX Codex

nestjs-professional-software-engineering — Claude Code skill

nestjs-professional-software-engineering — a skill for Claude Code and Cursor designs, implements, refactors, and tests production-quality NestJS and TypeScript software. Runs during feature development, API creation, and bug fixes.

MIT 556 installs ★ 26 updated 2026-11-14

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add amirtaherkhani/nestjs-skills --skill nestjs-professional-software-engineering -a claude-code
Open on GitHub

What nestjs-professional-software-engineering does

This skill handles repository inspection, version-appropriate syntax selection, minimal implementation, and verification for NestJS projects. It checks local conventions, compiler versions, and official documentation before altering any code.

The workflow covers inspection, impact analysis, syntax selection, design, implementation, and deterministic testing. It coordinates with architectural and audit skills to maintain clean boundaries and preserve public behavior during refactoring or feature additions.

What it helps with

  • design NestJS features and APIs
  • refactor TypeScript codebase
  • fix bugs and handle edge cases
  • write deterministic tests
  • verify build and type safety

Example prompts for the agent

  • Design a new REST API endpoint in NestJS
  • Refactor the users module to use modern TypeScript syntax
  • Write tests for the payment service

How to install nestjs-professional-software-engineering

1Skills CLI (Vercel)

npx skills add amirtaherkhani/nestjs-skills --skill nestjs-professional-software-engineering -a claude-code

2Manually: put the files in place

~/.claude/skills/nestjs-professional-software-engineering/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/nestjs-professional-software-engineering/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about nestjs-professional-software-engineering

How to install nestjs-professional-software-engineering in Claude Code?

Run npx skills add amirtaherkhani/nestjs-skills --skill nestjs-professional-software-engineering -a claude-code followed by ~/.claude/skills/nestjs-professional-software-engineering/SKILL.md.

What does nestjs-professional-software-engineering do?

It automates the design, implementation, debugging, refactoring, and verification of production-grade NestJS and TypeScript applications.

What is needed to run nestjs-professional-software-engineering?

It requires a supported AI coding assistant environment like Claude Code or Cursor and a working NestJS repository.

Source text

SKILL.md · MIT
---
name: nestjs-professional-software-engineering
description: 'Designs, implements, refactors, debugs, reviews, and verifies production-quality NestJS and TypeScript software. Use for NestJS feature development, bug fixes, APIs, libraries, testing, maintainability, developer experience, idiomatic syntax, or syntactic sugar. It inspects the current project and official version-appropriate documentation before selecting syntax, preserves public behavior, and tests the result. When other skills also apply, reconcile ownership before mutation.'
license: MIT
metadata:
  author: amirtaherkhani
  version: '2.1.1'
---

# Professional Software Engineering

Produce correct, idiomatic, secure, readable, maintainable, testable, and extensible NestJS software while respecting the existing project.

## Pre-execution conflict guard

Before editing files or running any state-changing command, reconcile active instructions. Read-only inspection may continue.

### Prerequisites

Inspect repository instructions, working tree, manifests, installed versions, source/callers, contracts, conventions, and checks. Preserve unrelated changes. Verify uncertain or version-sensitive syntax against installed types/source and official documentation; never invent an API. Read other active skills only when their decisions overlap.

### Primary ownership

This skill owns project inspection, minimal implementation, version-compatible syntax, API ergonomics, testing, and verification. When installed and relevant, coordinate with:

- `nestjs-architecture-principles`: module, dependency, data, and transaction boundaries.
- `nestjs-oop-design-patterns`: object responsibilities, invariants, and patterns.
- `nestjs-features-performance`: lifecycle, API/security, testing, runtime, and performance.
- `nestjs-code-audit`: read-only quality evidence and deduplicated reporting.
- `nestjs-feature-audit`: branch-specific roadmap gate and feature reporting.
- `nestjs-git-commit-pr-message`: authorized Git publication and CI follow-up.

These are decision boundaries, not required dependencies. Retain domain ownership when handing work to another workflow.

### Conflict test

Check for incompatible edits/contracts, command order or side effects, competing owners, and unmet version, evidence, authorization, or repository prerequisites. Resolve using explicit user intent, repository contracts, verified runtime constraints, then the narrowest owner. Assign one lead per decision; do not create parallel designs to satisfy incompatible advice. If a material conflict remains, stop before mutation and ask for the smallest missing decision. Audits stay read-only; explicit fix authorization applies in a distinct implementation phase.

## Required workflow

Before scaffolding or introducing a new boundary, record the [project profile](references/project-profile-and-scaffolding.md). Follow healthy local conventions and verify the installed generator/version contract.

For implementation requests, complete the workflow through mutation and verification. For review or diagnosis requests, inspect and report evidence without modifying files unless the user also authorizes implementation.

### 1. Inspect

1. Establish repository scope and applicable instructions.
2. Identify the language, framework, runtime, package manager, and exact relevant versions.
3. Read relevant implementation, callers, tests, configuration, manifests, and public contracts.
4. Search for analogous features and naming, error, test, and API conventions.
5. Determine focused and broader test, type-check, lint, format, build, and smoke-test commands.

Do not begin with a broad rewrite. Establish current behavior before changing it.

### 2. Understand

Define:

- requested outcome and observable acceptance criteria;
- affected boundaries and consumers;
- compatibility, security, data, performance, deployment, and migration implications;
- assumptions that would materially change the solution.

Ask only when a missing decision materially affects architecture, public behavior, security, data, cost, or compatibility.

### 3. Select the clearest valid syntax

Use this evidence order:

1. Existing repository conventions and compatible public behavior.
2. Installed compiler, runtime, package versions, types, and source.
3. Official version-appropriate language or framework documentation.
4. A minimal local experiment or type-check when documentation leaves ambiguity.
5. Community examples only as discovery evidence, never as the API contract.

Compare at least the direct, explicit form with any convenient syntax. Prefer modern idioms when they are supported, familiar in the project, and clearer at the call site and implementation site.

Load [syntax-and-idioms.md](references/syntax-and-idioms.md) when selecting language or framework syntax.

### 4. Design the smallest coherent change

The design must be:

- idiomatic for the detected language and framework;
- consistent with existing architecture and conventions;
- cohesive, testable, secure by default, and backward-compatible unless a break is authorized;
- explicit about meaningful state changes, effects, failure modes, cost, and control.

For public APIs, make common operations obvious and invalid usage difficult. Prefer progressive disclosure: a convenient path for common cases and a lower-level path only when callers need meaningful control.

Load [syntactic-sugar.md](references/syntactic-sugar.md) for the decision test and API examples.

### 5. Implement

- Use valid, modern syntax supported by the detected toolchain.
- Keep functions, classes, modules, components, and services focused.
- Follow established naming, formatting, organization, validation, and error conventions.
- Validate untrusted input at boundaries and protect sensitive information.
- Handle failures explicitly with actionable, non-leaking errors.
- Consider concurrency, transactions, idempotency, retries, timeouts, cancellation, cleanup, and observability when relevant.
- Avoid unnecessary dependencies, speculative abstractions, clever one-liners, hidden global state, implicit side effects, and unrelated cleanup.
- Comment intent and constraints, not self-explanatory syntax.

### 6. Test and verify

Add or update deterministic tests for observable behavior, relevant edge cases, invalid input, failure paths, security-sensitive behavior, regressions, and public compatibility.

Run the checks appropriate to the change:

1. Focused tests.
2. Broader tests when the risk warrants them.
3. Type checking or compilation.
4. Lint and formatting verification.
5. Build or packaging.
6. Runtime, generated-contract, or migration smoke checks when practical.

Do not weaken tests or controls to obtain a pass. Do not claim a check passed unless it ran successfully.

Load [implementation-verification.md](references/implementation-verification.md) for risk-based verification.

### 7. Report

Lead with the completed outcome, then state:

- important design and syntax decisions;
- files or areas changed;
- checks executed and their results;
- remaining limitations, risks, migrations, or follow-up.

Keep the report concise and distinguish verified facts from assumptions or unrun checks.

## Syntactic sugar rule

Use syntactic sugar only when it:

- reduces meaningful ceremony or repeated misuse;
- improves readability for the repository's actual maintainers;
- preserves predictable behavior, typing, debugging, and composability;
- does not conceal meaningful cost, I/O, state changes, network activity, authorization, transactions, error behavior, or lifecycle;
- preserves an explicit path when advanced callers need control; and
- can be documented and tested with realistic examples.

Reject sugar that merely shortens code, creates a private mini-language, overloads ambiguous inputs, relies on surprising coercion, or makes stack traces and errors harder to understand.

## Expected response

For implementation work, report the delivered behavior and verification. When syntax choice is central, also state:

- **Observed convention:** the relevant repository pattern.
- **Options considered:** explicit and convenient forms.
- **Selected syntax:** why it is supported and clearest.
- **Hidden-behavior check:** effects, cost, failures, and control that remain visible.
- **Compatibility:** affected callers and migration, if any.

Do not return only a proposed snippet when the user requested implementation.

## Reference routing

| Task | Load |
| --- | --- |
| Choose idiomatic, version-compatible syntax | [syntax-and-idioms.md](references/syntax-and-idioms.md) |
| Design or review syntactic sugar and public API ergonomics | [syntactic-sugar.md](references/syntactic-sugar.md) |
| Scope implementation and select verification depth | [implementation-verification.md](references/implementation-verification.md) |

© amirtaherkhani · MIT · amirtaherkhani/nestjs-skills

Similar skills

All skills for Backend and APIs →

From the same set7

nestjs-architecture-principles The nestjs-architecture-principles Claude Code skill plans and reviews NestJS application architecture. It activates for module-boundary changes, dependency cycles, or decisions about CQRS and microservices. CX Codex +1 592installs nestjs-oop-design-patterns nestjs-oop-design-patterns — a Claude Code skill for applying OOP, SOLID, and design patterns to NestJS and TypeScript. It activates during code changes or when investigating object-design problems. CX Codex +1 560installs nestjs-features-performance nestjs-features-performance is a Claude Code skill that helps select and implement NestJS runtime features for APIs, security, testing, and performance. It applies to NestJS server work, not frontend-only performance tasks. CX Codex +1 550installs nestjs-code-audit nestjs-code-audit — a skill for Claude Code and Codex inspects a NestJS repository and produces a prioritized, evidence-backed quality report. It executes static and architectural checks strictly in read-only mode. CX Codex +1 515installs nestjs-feature-audit The nestjs-feature-audit Claude Code skill checks a NestJS feature against its roadmap and produces a report backed by evidence. It runs on requests to verify feature coverage, migration progress, or differences from an acceptance plan. CX Codex +1 454installs nestjs-git-commit-pr-message The nestjs-git-commit-pr-message Claude Code skill prepares Git changes in NestJS projects for commits, pushes, and pull requests. It activates for requests to draft Git text, publish changes, or check CI results. CX Codex +1 410installs

Project sponsors

Companies that keep this analytics open