⚡ Claude Command Library (Reusable Templates)

⚡ Claude Command Library (Reusable Templates)

🧠 How to Use This Library

Each command follows this structure:

[ROLE] + [INTENT] + [CONSTRAINTS] + [OUTPUT FORMAT]

You can mix, chain, and automate these.

🔹 1. Architecture & Design Commands

🏗️ System Design Generator

Act as a senior solutions architect.

Design a scalable system for [PROBLEM].

Include components, data flow, and trade-offs.

Use cloud-native patterns and microservices where appropriate.

🔄 Pattern Recommendation

Analyze this requirement and recommend the best design patterns.

Explain why each pattern fits and where it should be applied.

Avoid overengineering.

🧱 Layered Architecture Enforcer

Refactor this system into a layered architecture:

- Inbound adapters

- Core domain (business logic)

- Outbound adapters

Ensure clear separation of concerns.

🔹 2. Code Generation & Refactoring

⚙️ Clean Code Generator

Generate production-ready code for this requirement.

Follow clean code principles, SOLID, and proper naming conventions.

Include error handling and logging.

♻️ Safe Refactor (No Behavior Change)

Refactor this code without changing functionality.

Improve readability, maintainability, and structure.

Do not introduce new dependencies.

🔍 Code Review (Senior Level)

Act as a senior engineer.

Review this code for:

- Bugs

- Performance issues

- Maintainability

- Security risks

Provide actionable improvements.

🔹 3. Testing & Validation

🧪 Test-First Development

Write unit tests first for this requirement.

Then implement the code to satisfy the tests.

Use [FRAMEWORK].

✅ Validation Pass

Validate this solution for:

- Edge cases

- Performance bottlenecks

- Failure scenarios

Suggest improvements.

🔥 Chaos & Failure Testing

Simulate failure scenarios for this system.

What breaks first?

How should it recover?

Recommend resilience improvements.

🔹 4. Intent-Driven Engineering (Your Superpower)

📄 Intent File Generator

Convert this requirement into an intent file:

- Objective

- Inputs

- Outputs

- Constraints

- Success criteria

Make it executable by an AI agent.

🔁 Intent → Implementation

Take this intent file and generate a full implementation plan.

Break it into:

- Services

- APIs

- Data models

- Execution steps

🤖 Agent Task Definition

Convert this task into an agent-executable workflow.

Include:

- Step-by-step actions

- Decision points

- Validation checkpoints

🔹 5. DevOps & Pipeline Commands

🚀 CI/CD Pipeline Generator

Design a CI/CD pipeline for this project.

Include:

- Build

- Test

- Security scan

- Deployment stages

Use Jenkins or GitHub Actions.

🔄 Multi-System Integration

Design a routing layer that sends data to multiple backends.

Use the adapter pattern.

Ensure fault tolerance and retry handling.

📊 Observability Setup

Add observability to this system:

- Logging

- Metrics

- Tracing

Include recommended tools and patterns.

🔹 6. Performance & Optimization

⚡ Performance Optimizer

Optimize this system for performance.

Focus on:

- Latency

- Throughput

- Resource usage

Explain trade-offs.

📉 Bottleneck Analyzer

Identify bottlenecks in this system.

Rank them by impact.

Provide fixes.

🔹 7. Documentation & Knowledge

📘 Developer Documentation

Generate developer documentation for this system.

Include:

- Overview

- Setup

- APIs

- Examples

🎓 Teach Mode (Learn • Teach • Master)

Explain this concept step-by-step.

Start simple, then go deeper.

Include real-world examples.

🔹 8. Advanced “Power Moves” (Elite Usage)

🧠 Multi-Step Orchestration

Do the following in order:

1. Analyze the problem

2. Propose architecture

3. Validate approach

4. Generate code

5. Add tests

6. Review for improvements

🔐 Constraint Lock (Critical for Enterprise)

Use only:

- Java 17

- Spring Boot

- Kafka

Do not introduce new frameworks or tools.

🧬 Self-Improving Loop

Generate a solution.

Then critique your own solution.

Then improve it.

Repeat once more.

🧯 Production Mindset Mode

Explain this system as if I am responsible for production outages.

Focus on risks, failure points, and recovery strategies.

🔥 The Real Secret (What Most People Miss)

This is not a list of prompts.

This is a command operating system.

You:

• Chain commands

• Enforce constraints

• Define intent

And Claude becomes:

Your execution engine

⚡ Next Level (Where You Should Go Next)

You’re already thinking bigger than prompts.

We can turn this into:

1.

Jenny Command Engine

• Store these as reusable templates

• Auto-select based on intent

• Plug into your agent system

2.

Intent-Driven CLI

Example:

/generate-service

/refactor-safe

/create-intent

/run-validation

3.

Enterprise Command Catalog

• Standardized across your 50+ repos

• Enforced via pipelines

• Used by every dev