Developer Kit for Claude Code (giuseppe-trisciuoglio/developer-kit)

Developer Kit for Claude Code

https://github.com/giuseppe-trisciuoglio/developer-kit
Admin
Developer Kit for Claude Code is a modular plugin system providing reusable skills, agents, and...

Tokens:2,134,018
Snippets:12,501
Trust Score:7.5
Update:1 month ago
Show doc for...
Context Summary (auto-generated)
Raw
# Developer Kit for Claude Code

Developer Kit for Claude Code is a modular plugin system providing reusable skills, agents, and commands that automate development tasks across multiple programming languages and frameworks. The toolkit teaches Claude how to perform development tasks in a repeatable, systematic way by leveraging specialized agents for code review, testing, architecture design, debugging, and documentation generation. With 10 independent plugins containing 92 skills, 43 agents, and 36 commands, developers can install only the components relevant to their technology stack.

The architecture follows a marketplace model where each plugin focuses on a specific domain: core workflow commands, Java/Spring Boot development, TypeScript/NestJS/React development, Python, PHP/WordPress, AWS CloudFormation, AI/ML capabilities, DevOps, and project management. Skills load on-demand to minimize token consumption, while agents coordinate complex multi-phase workflows. The system integrates seamlessly with Claude Code CLI, Claude Desktop, and other AI-powered development tools like GitHub Copilot CLI and OpenCode.

## Installation

Install the complete plugin marketplace or individual plugins for your technology stack.

```bash
# Install from marketplace (recommended for Claude Code)
/plugin marketplace add giuseppe-trisciuoglio/developer-kit

# Install from local directory after cloning
git clone https://github.com/giuseppe-trisciuoglio/developer-kit.git
/plugin install /path/to/developer-kit

# Install using Makefile for multiple CLI tools
make install-claude        # Interactive installer for Claude Code
make install-opencode      # Install for OpenCode CLI
make install-copilot       # Install for GitHub Copilot CLI
make install               # Install for all detected CLIs
make status                # Show installation status
```

## Brainstorming Command

Transform ideas into fully-formed designs through a systematic 9-phase process including context discovery, approach exploration, codebase analysis, design validation, professional documentation generation, and next-step recommendations.

```bash
# Start brainstorming a new feature
/developer-kit:devkit.brainstorm Add user authentication with JWT tokens

# Brainstorm a complex integration
/developer-kit:devkit.brainstorm Implement real-time notifications using WebSockets

# Design a refactoring approach
/developer-kit:devkit.brainstorm Refactor the payment processing module to be more maintainable

# Plan a performance improvement
/developer-kit:devkit.brainstorm Design a caching strategy to reduce API response times

# Architecture design
/developer-kit:devkit.brainstorm Design a microservices architecture for the reporting module
```

## Feature Development Command

Implement new features with a guided 7-phase workflow: discovery, codebase exploration, clarifying questions, architecture design, implementation, quality review, and summary. Supports language-specific agents for Java, TypeScript, NestJS, React, Python, and AWS.

```bash
# General feature development (uses general-purpose agents)
/developer-kit:devkit.feature-development Add user authentication

# Java/Spring Boot feature with specialized agents
/developer-kit:devkit.feature-development --lang=spring Add REST API for user management
/developer-kit:devkit.feature-development --lang=java Implement caching layer for products

# TypeScript feature development
/developer-kit:devkit.feature-development --lang=typescript Add GraphQL resolver for user queries

# NestJS backend feature
/developer-kit:devkit.feature-development --lang=nestjs Implement authentication module with JWT

# React frontend feature
/developer-kit:devkit.feature-development --lang=react Create dashboard with charts and user filters

# Python feature development
/developer-kit:devkit.feature-development --lang=python Implement REST API with FastAPI and SQLAlchemy

# AWS infrastructure feature
/developer-kit:devkit.feature-development --lang=aws Design multi-region high availability architecture
/developer-kit:devkit.feature-development --lang=aws Create ECS Fargate infrastructure with auto scaling
```

## Fix and Debugging Command

Systematically diagnose and fix bugs through problem capture, evidence collection, root cause analysis, fix design, implementation, verification, and documentation. Uses specialized debugger agents with language-specific expertise.

```bash
# Debug with error message
/developer-kit:devkit.fix-debugging NullPointerException in UserService.getUserProfile()

# Debug behavioral issue
/developer-kit:devkit.fix-debugging Users are seeing stale data after profile update

# Java/Spring Boot debugging
/developer-kit:devkit.fix-debugging --lang=spring Bean injection failing in OrderService

# TypeScript debugging
/developer-kit:devkit.fix-debugging --lang=typescript Type error in async handler

# NestJS debugging
/developer-kit:devkit.fix-debugging --lang=nestjs Dependency injection circular reference in AuthModule

# React debugging
/developer-kit:devkit.fix-debugging --lang=react Component not re-rendering after state update

# Python debugging
/developer-kit:devkit.fix-debugging --lang=python TypeError in async FastAPI endpoint handler

# AWS infrastructure debugging
/developer-kit:devkit.fix-debugging --lang=aws CloudFormation stack creation failing with IAM error
/developer-kit:devkit.fix-debugging --lang=aws Lambda function timeout causing API Gateway 504 errors

# Performance issue
/developer-kit:devkit.fix-debugging API response time increased from 50ms to 2s after last deploy
```

## Code Refactoring Command

Safely refactor code with comprehensive analysis of dependencies, usages, and test coverage. Supports backward-compatible, breaking changes, or internal-only refactoring strategies with multi-phase verification.

```bash
# File-level refactoring
/developer-kit:devkit.refactor --scope=file Extract utility methods from UserService

# Module-level Java/Spring Boot refactoring
/developer-kit:devkit.refactor --lang=spring --scope=module Refactor repository layer to use specification pattern

# Breaking change refactoring
/developer-kit:devkit.refactor --lang=java Restructure payment module API for v2

# TypeScript refactoring
/developer-kit:devkit.refactor --lang=typescript Convert callbacks to async/await in data layer

# NestJS refactoring
/developer-kit:devkit.refactor --lang=nestjs Refactor authentication to use guards instead of middleware

# React component refactoring
/developer-kit:devkit.refactor --lang=react Extract shared hooks from dashboard components

# Python refactoring
/developer-kit:devkit.refactor --lang=python Refactor data access layer to use repository pattern

# AWS infrastructure refactoring
/developer-kit:devkit.refactor --lang=aws Refactor monolithic CloudFormation template into nested stacks
/developer-kit:devkit.refactor --lang=aws Migrate from EC2-based to serverless architecture
```

## Document Generation Command

Generate professional technical and business documents with multi-language support including assessments, feature specifications, analysis documents, and process documentation.

```bash
# Generate technical assessment in English
/developer-kit:devkit.generate-document --type=assessment List all application features and their current status

# Feature specification in Italian
/developer-kit:devkit.generate-document --lang=it --type=feature User authentication with OAuth2 integration

# Security analysis in Spanish
/developer-kit:devkit.generate-document --lang=es --type=analysis Security vulnerabilities and compliance gaps

# Process documentation in French
/developer-kit:devkit.generate-document --lang=fr --type=process CI/CD pipeline and deployment procedures

# Custom report in German
/developer-kit:devkit.generate-document --lang=de --type=custom API design patterns and best practices

# Gap analysis in Portuguese
/developer-kit:devkit.generate-document --lang=pt --type=analysis Current vs. target architecture comparison
```

## GitHub Pull Request Command

Create GitHub pull requests with automatic branch creation, intelligent commit message generation following Conventional Commits, and multi-language description support.

```bash
# Create PR with title
/developer-kit:devkit.github.create-pr "Add user profile API"

# Create PR targeting specific branch
/developer-kit:devkit.github.create-pr "Fix authentication timeout" develop

# Create PR with Italian description
/developer-kit:devkit.github.create-pr "Aggiungere validazione email" main it

# Auto-generate PR from changes
/developer-kit:devkit.github.create-pr
```

## Long-Running Agent (LRA) Workflow

Manage multi-session development projects with state persistence, feature tracking, and checkpoint recovery for complex implementations spanning multiple conversations.

```bash
# Initialize LRA workflow for a project
/developer-kit:devkit.lra.init

# Start a new coding session (reads progress, selects next feature)
/developer-kit:devkit.lra.start-session

# Add a new feature to the backlog
/developer-kit:devkit.lra.add-feature Implement payment processing

# Create checkpoint to save progress
/developer-kit:devkit.lra.checkpoint

# Mark feature as complete
/developer-kit:devkit.lra.mark-feature payment-processing complete

# Check current status
/developer-kit:devkit.lra.status

# Recover from previous session
/developer-kit:devkit.lra.recover
```

## Spring Boot REST API Skill

Build production-ready REST APIs with consistent patterns for resource design, HTTP methods, status codes, validation, error handling, pagination, and security headers.

```java
// Complete CRUD Controller with validation and pagination
@RestController
@RequestMapping("/v1/users")
@RequiredArgsConstructor
@Slf4j
public class UserController {
    private final UserService userService;

    @GetMapping
    public ResponseEntity<Page<UserResponse>> getAllUsers(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int pageSize) {
        Page<UserResponse> users = userService.getAll(page, pageSize);
        return ResponseEntity.ok(users);
    }

    @GetMapping("/{id}")
    public ResponseEntity<UserResponse> getUserById(@PathVariable Long id) {
        return ResponseEntity.ok(userService.getById(id));
    }

    @PostMapping
    public ResponseEntity<UserResponse> createUser(@Valid @RequestBody CreateUserRequest request) {
        UserResponse created = userService.create(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(created);
    }

    @PutMapping("/{id}")
    public ResponseEntity<UserResponse> updateUser(
            @PathVariable Long id,
            @Valid @RequestBody UpdateUserRequest request) {
        return ResponseEntity.ok(userService.update(id, request));
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userService.delete(id);
        return ResponseEntity.noContent().build();
    }
}

// Request DTO with validation
@Data
public class CreateUserRequest {
    @NotBlank(message = "User name cannot be blank")
    private String name;

    @Email(message = "Valid email required")
    private String email;
}

// Global Exception Handler
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidationException(
            MethodArgumentNotValidException ex, WebRequest request) {
        String errors = ex.getBindingResult().getFieldErrors().stream()
                .map(f -> f.getField() + ": " + f.getDefaultMessage())
                .collect(Collectors.joining(", "));

        ErrorResponse errorResponse = new ErrorResponse(
                HttpStatus.BAD_REQUEST.value(),
                "Validation Error",
                "Validation failed: " + errors,
                request.getDescription(false).replaceFirst("uri=", "")
        );
        return new ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
    }
}
```

## NestJS Framework Skill

Build NestJS applications with comprehensive patterns for modules, controllers, services, Drizzle ORM integration, authentication guards, validation pipes, and testing.

```typescript
// Database Schema with Drizzle ORM
import { pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  name: text('name').notNull(),
  email: text('email').notNull().unique(),
  createdAt: timestamp('created_at').defaultNow(),
});

// Repository with Drizzle
@Injectable()
export class UserRepository {
  constructor(private db: DatabaseService) {}

  async findAll() {
    return this.db.database.select().from(users);
  }

  async findOne(id: number) {
    const result = await this.db.database
      .select()
      .from(users)
      .where(eq(users.id, id))
      .limit(1);
    return result[0];
  }

  async create(data: typeof users.$inferInsert) {
    const result = await this.db.database
      .insert(users)
      .values(data)
      .returning();
    return result[0];
  }
}

// JWT Authentication Guard
@Injectable()
export class JwtAuthGuard implements CanActivate {
  constructor(private jwtService: JwtService) {}

  canActivate(context: ExecutionContext) {
    const request = context.switchToHttp().getRequest();
    const token = request.headers.authorization?.split(' ')[1];

    if (!token) return false;

    try {
      const decoded = this.jwtService.verify(token);
      request.user = decoded;
      return true;
    } catch {
      return false;
    }
  }
}

// Unit Testing with Mocks
describe('UsersService', () => {
  let service: UsersService;
  let repository: jest.Mocked<UserRepository>;

  beforeEach(async () => {
    const mockRepository = {
      findAll: jest.fn(),
      findOne: jest.fn(),
      create: jest.fn(),
    } as any;

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        UsersService,
        { provide: UserRepository, useValue: mockRepository },
      ],
    }).compile();

    service = module.get<UsersService>(UsersService);
    repository = module.get(UserRepository);
  });

  it('should return all users', async () => {
    const expectedUsers = [{ id: 1, name: 'John', email: 'john@example.com' }];
    repository.findAll.mockResolvedValue(expectedUsers);

    const result = await service.findAll();
    expect(result).toEqual(expectedUsers);
  });
});
```

## Task Tool Agent Integration

Launch specialized sub-agents using the Task tool for parallel code exploration, architecture design, and code review within development commands.

```javascript
// Launch code explorer agent for codebase analysis
Task(
  description: "Explore similar features",
  prompt: "Find features similar to [feature] and trace through their implementation comprehensively. Focus on understanding patterns, architecture, and integration points.",
  subagent_type: "developer-kit:general-code-explorer"
)

// Launch architecture design agent
Task(
  description: "Design feature architecture",
  prompt: "Design a pragmatic architecture for [feature] considering speed and quality. Provide step-by-step implementation plan with trade-offs.",
  subagent_type: "developer-kit:general-software-architect"
)

// Launch code review agent
Task(
  description: "Review implementation",
  prompt: "Review the implemented code focusing on simplicity, correctness, conventions, and potential regressions.",
  subagent_type: "developer-kit:general-code-reviewer"
)

// Java/Spring Boot specialized agents
Task(
  description: "Spring Boot architecture review",
  prompt: "Design Spring Boot architecture following clean architecture principles",
  subagent_type: "developer-kit-java:java-software-architect-review"
)

// TypeScript/NestJS specialized agents
Task(
  description: "NestJS code review",
  prompt: "Review NestJS code for module structure, DI patterns, and TypeScript best practices",
  subagent_type: "developer-kit-typescript:nestjs-code-review-expert"
)

// AWS specialized agents
Task(
  description: "Design AWS architecture",
  prompt: "Design scalable cloud architecture following Well-Architected Framework",
  subagent_type: "developer-kit-aws:aws-solution-architect-expert"
)
```

## Prompt Engineering Skill

Create and optimize prompts with few-shot learning, chain-of-thought reasoning, template systems, and systematic A/B testing for production-ready AI applications.

```markdown
# Few-Shot Learning Template
Example 1 (Basic case):
Input: {representative_input}
Output: {expected_output}

Example 2 (Edge case):
Input: {challenging_input}
Output: {robust_output}

Example 3 (Error case):
Input: {problematic_input}
Output: {corrected_output}

Now handle: {target_input}

# Chain-of-Thought Template
Let's approach this step-by-step:

Step 1: {break_down_the_problem}
Analysis: {detailed_reasoning}

Step 2: {identify_key_components}
Analysis: {component_analysis}

Step 3: {synthesize_solution}
Analysis: {solution_justification}

Final Answer: {conclusion_with_confidence}

# System Prompt Framework
You are an expert {role} specializing in {domain} with {experience_level} of experience.

## Core Capabilities
- List specific capabilities and expertise areas
- Define scope of knowledge and limitations

## Behavioral Guidelines
- Specify interaction style and communication approach
- Define error handling and uncertainty protocols

## Output Requirements
- Specify format expectations and structural requirements
- Define content inclusion and exclusion criteria

## Safety and Ethics
- Include content policy adherence
- Specify bias mitigation requirements
```

## Java Code Review Command

Execute comprehensive code reviews for Java/Spring Boot projects covering code quality, security, performance, architecture, and testing patterns.

```bash
# Review entire project
/developer-kit-java:devkit.java.code-review

# Review specific class
/developer-kit-java:devkit.java.code-review UserService.java

# Security-focused review
/developer-kit-java:devkit.java.security-review

# Architecture review
/developer-kit-java:devkit.java.architect-review

# Dependency audit
/developer-kit-java:devkit.java.dependency-audit

# Generate unit tests
/developer-kit-java:devkit.java.write-unit-tests UserService

# Generate integration tests
/developer-kit-java:devkit.java.write-integration-tests UserController
```

## TypeScript Code Review Command

Review TypeScript/React/NestJS code for type safety, best practices, security vulnerabilities, and framework-specific patterns.

```bash
# TypeScript code review
/developer-kit-typescript:devkit.typescript.code-review

# React component review
/developer-kit-typescript:devkit.react.code-review

# TypeScript security review
/developer-kit-typescript:devkit.ts.security-review
```

## Plugin Configuration

Configure plugins using plugin.json manifests that declare agents, commands, and skills for each technology domain.

```json
{
  "name": "developer-kit-java",
  "version": "2.2.0",
  "description": "Comprehensive Java development toolkit with Spring Boot, testing, LangChain4J, and AWS integration",
  "keywords": ["java", "spring-boot", "junit", "langchain4j", "aws-sdk", "testing"],
  "agents": [
    "./agents/spring-boot-backend-development-expert.md",
    "./agents/spring-boot-code-review-expert.md",
    "./agents/java-refactor-expert.md",
    "./agents/java-security-expert.md",
    "./agents/langchain4j-ai-development-expert.md"
  ],
  "commands": [
    "./commands/devkit.java.code-review.md",
    "./commands/devkit.java.generate-crud.md",
    "./commands/devkit.java.write-unit-tests.md"
  ],
  "skills": [
    "./skills/spring-boot-rest-api-standards",
    "./skills/spring-boot-security-jwt",
    "./skills/langchain4j-rag-implementation-patterns",
    "./skills/aws-sdk-java-v2-core"
  ]
}
```

## Summary

Developer Kit for Claude Code provides a comprehensive automation framework for software development workflows across Java/Spring Boot, TypeScript/NestJS/React, Python, PHP/WordPress, and AWS CloudFormation. The primary use cases include guided feature development from ideation to implementation, systematic bug fixing with root cause analysis, safe code refactoring with compatibility verification, professional documentation generation, and GitHub workflow automation. Each command follows a multi-phase approach with specialized agents handling code exploration, architecture design, implementation, and quality review.

Integration patterns center on the Task tool for launching specialized sub-agents, the AskUserQuestion tool for structured user interaction, and TodoWrite for progress tracking. Developers can mix and match plugins based on their technology stack, with the core plugin providing universal commands like brainstorm, feature-development, fix-debugging, and refactor. Skills load on-demand when their expertise is needed, ensuring efficient token usage while providing deep domain knowledge for Spring Boot patterns, NestJS modules, React components, AWS CloudFormation templates, prompt engineering, and more. The modular architecture supports both project-local installation for Claude Code and global installation for other AI CLI tools.