Skip to main content
skill CX Codex

generic-feature-developer — Claude Code skill: what it does

generic-feature-developer walks a feature from reading the codebase to picking patterns, shipping small commits and checking edge cases before you close it.

MIT 142 installs ★ 114 updated 2026-11-06

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add travisjneuman/.claude --skill generic-feature-developer -a claude-code
Open on GitHub

What generic-feature-developer does

The skill moves a feature through four stages: read CLAUDE.md and list the files that will change, choose patterns and sketch the data flow, implement in small commits a reviewer can follow, then check the diff against edge cases and update the docs.

Folder layouts come ready for three kinds of project: a static site with css/ and js/, a React/Next.js tree holding components/, hooks/, stores/ and services/, and a NestJS backend where a feature is a module with a controller, a service and DTOs. Decision tables cover scope, build versus integrate, state management and API design, including error format and pagination.

Styling and UX calls sit outside it: those get handed to generic-design-system and generic-ux-designer. Tests appear only when you ask for them. The closing links point at ../_shared/CODE_REVIEW_STANDARDS.md and DESIGN_PATTERNS.md in the same repository, so bring the repo along or the links lead nowhere.

What it helps with

  • choose between a hand-written module and an existing library
  • decide where state belongs: local hook, store or server cache
  • break a feature into commits a reviewer can actually read
  • settle one error response shape and one pagination scheme for the API
  • run a pre-merge checklist before calling the feature done

Example prompts for the agent

  • Add CSV export for the report: show the plan and affected files first, then the code.
  • Design a POST /invoices endpoint inside the NestJS module, with DTO, validation and error format.
  • Should the filter state live in the component or in Zustand? Compare both and pick one.

How to install generic-feature-developer

1Skills CLI (Vercel)

npx skills add travisjneuman/.claude --skill generic-feature-developer -a claude-code

2Manually: put the files in place

~/.claude/skills/generic-feature-developer/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/generic-feature-developer/

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

Questions about generic-feature-developer

How do I install generic-feature-developer in Claude Code?

Run npx skills add travisjneuman/.claude --skill generic-feature-developer -a claude-code. The skill then sits at ~/.claude/skills/generic-feature-developer/SKILL.md.

What does generic-feature-developer do?

It sets the order of work on a feature: read CLAUDE.md and the affected files, pick patterns and data flow, build in small commits, then review the diff and refresh the docs.

Does it write tests?

Only on request. The checklist marks tests as written when asked, and a table by layer names the tooling for component, unit, integration and end-to-end checks.

Source text

SKILL.md · MIT
---
name: generic-feature-developer
description: Guide feature development with architecture patterns for any tech stack. Covers frontend, backend, full-stack, and automation projects. Use when adding new features, modifying systems, or planning changes.
---

# Generic Feature Developer

Guide feature development across any tech stack.

## When to Use This Skill

**Use for:**

- Adding new features to existing codebase
- Modifying or extending current systems
- Planning architectural changes
- Choosing between implementation approaches
- Designing data flow for new functionality

**Don't use when:**

- Pure UI/styling work → use `generic-design-system`
- UX design decisions → use `generic-ux-designer`
- Code review → use `generic-code-reviewer`

## Development Workflow

1. **Understand** - Read CLAUDE.md, identify affected files, list constraints
2. **Plan** - Choose patterns, design data flow, identify edge cases
3. **Implement** - Small reviewable changes, commit frequently
4. **Review & Document** - Review the diff against edge cases and callers, update docs, performance check

## Architecture by Project Type

### Static Sites

```
project/
├── index.html
├── css/           # variables.css, style.css
├── js/            # main.js, utils.js
└── assets/
```

**Patterns:** CSS variables, ES modules, event delegation

### React/Next.js

```
src/
├── components/    # ui/, features/, layout/
├── hooks/
├── stores/
├── services/
└── types/
```

**Patterns:** Container/Presentational, custom hooks, Zustand/React Query

### NestJS Backend

```
src/
├── modules/[feature]/
│   ├── feature.module.ts
│   ├── feature.controller.ts
│   ├── feature.service.ts
│   └── dto/
└── common/        # guards, decorators
```

**Patterns:** Module organization, DTOs, Guards, Prisma

## Feature Decision Framework

### Scope Assessment (First)

| Scope                 | Action                                |
| --------------------- | ------------------------------------- |
| Single component      | Implement directly                    |
| Cross-cutting concern | Design interface first                |
| New subsystem         | Create architecture doc, get approval |

### Build vs Integrate

| Factor                   | Build Custom | Use Library |
| ------------------------ | ------------ | ----------- |
| Core to product          | Yes          |             |
| Commodity feature        |              | Yes         |
| Tight integration needed | Yes          |             |
| Time-critical            |              | Yes         |
| Long-term ownership      | Yes          |             |

### State Management Selection

| Scope           | Solution                 |
| --------------- | ------------------------ |
| Component-local | useState/useReducer      |
| Feature-wide    | Context or Zustand slice |
| App-wide        | Zustand/Redux store      |
| Server state    | React Query/SWR          |
| Form state      | React Hook Form          |

### API Design Checklist

- [ ] RESTful or GraphQL decision documented
- [ ] Authentication method chosen
- [ ] Error response format standardized
- [ ] Pagination strategy defined
- [ ] Rate limiting considered

## Common Features

### Adding UI Component

1. Create component → 2. Export → 3. Review usage and edge cases → 4. Document

### Adding API Endpoint

1. Define route → 2. Add validation → 3. Implement service → 4. Review error paths

### Adding State Management

1. Define shape → 2. Create store → 3. Add actions → 4. Connect components

### Database Changes

1. Design schema → 2. Create migration → 3. Update models → 4. Add service

## Data Flow Patterns

### Frontend Data Flow

```
User Action → Event Handler → State Update → Re-render → UI Feedback
```

- **Optimistic updates:** Update UI immediately, rollback on error
- **Pessimistic updates:** Wait for server confirmation
- **Decision:** Optimistic for low-risk (likes), pessimistic for high-risk (payments)

### API Request Flow

```
Request → Auth Check → Validation → Business Logic → Database → Response
```

- Early exit on validation failure
- Transaction boundaries around multi-step operations
- Consistent error response format

### Event-Driven Patterns

| Event Type       | Approach                    |
| ---------------- | --------------------------- |
| User events      | Immediate feedback          |
| Server events    | WebSocket/SSE for real-time |
| Background tasks | Queue for long operations   |

## Error Handling Strategy

| Error Type   | Frontend                  | Backend            |
| ------------ | ------------------------- | ------------------ |
| Validation   | Inline field errors       | 400 + field errors |
| Auth         | Redirect to login         | 401/403            |
| Not Found    | Empty state or redirect   | 404                |
| Server Error | Generic message + retry   | 500 + log          |
| Network      | Offline indicator + queue | N/A                |

### Frontend Pattern

```typescript
try {
  await apiCall();
} catch (error) {
  if (error instanceof ValidationError) showFieldErrors(error.fields);
  else showGenericError();
}
```

### Backend Pattern

```typescript
if (err instanceof ValidationError)
  return res.status(400).json({ errors: err.errors });
if (err instanceof AuthError)
  return res.status(401).json({ message: "Unauthorized" });
```

## Testing Strategy (when the user asks for tests)

| Layer | Type        | Tools           |
| ----- | ----------- | --------------- |
| UI    | Component   | Testing Library |
| Logic | Unit        | Jest, Vitest    |
| API   | Integration | Supertest       |
| E2E   | End-to-end  | Cypress         |

## Performance

**Frontend:** Code splitting, lazy loading, memoization, debounce
**Backend:** DB indexing, caching, connection pooling, background jobs

## Feature Implementation Checklist

Before marking feature complete:

- [ ] Works for happy path
- [ ] Error states handled
- [ ] Loading states implemented
- [ ] Edge cases reviewed
- [ ] TypeScript types complete
- [ ] Tests written (only if the user asked for them)
- [ ] Documentation updated

## See Also

- [Code Review Standards](./../_shared/CODE_REVIEW_STANDARDS.md) - Quality checks
- [Design Patterns](./../_shared/DESIGN_PATTERNS.md) - UI patterns
- `generic-design-system` - For styling and visual consistency
- `generic-ux-designer` - For UX flow decisions
- Project `CLAUDE.md` - Workflow rules

**READ shared standards when:**

- Complex feature design → CODE_REVIEW_STANDARDS.md (architecture section)
- UI component patterns → DESIGN_PATTERNS.md (component section)

© travisjneuman · MIT · travisjneuman/.claude

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set117

The whole set →
vue-development vue-development — a Claude Code skill for building Vue 3 applications with the Composition API and Script Setup. Guides state setup in Pinia, custom composables, and Nuxt 3 full-stack tasks. CX Codex +1 143installs generic-design-system generic-design-system provides standard design system guidelines for AI coding agents, covering color tokens, typography, spacing scales, and component states. CX Codex +1 143installs event-driven-architecture The event-driven-architecture skill guides asynchronous system design around brokers, event flows, and distributed work. Use it when services must communicate through messages. CX Codex +1 143installs content-repurposer content-repurposer turns one piece of writing into a thread, a LinkedIn post, a carousel or a newsletter, and shifts the tone to match the channel. CX Codex +1 142installs generic-fullstack-design-system generic-fullstack-design-system is a Claude Code skill that helps configure design systems for Next.js and NestJS full-stack projects, including Tailwind tokens, shadcn/ui components, and dark mode. CX Codex +1 142installs tdd-workflow tdd-workflow — a skill for Claude Code, Codex, Cursor and other platforms that enforces test-driven development: first a failing test (RED), then minimal code to pass (GREEN), then refactoring. CX Codex +1 141installs core-workflow core-workflow is a skill with working protocols for agents: Git conventions, security and accessibility checklists, and task sizing. It loads for complex work or when a specific pattern is requested. CX Codex +1 141installs newsletter-creator newsletter-creator builds a company newsletter from a fixed outline: section order, a scoring pass over the links, and email layout rules to follow. CX Codex +1 140installs

Project sponsors

Companies that keep this analytics open