Torna alle skill
ai-coding-agent-toolkit
di Ashfaqbs
Windsurf—Non ancora valutato
La tua valutazione
Sintesi
Production-ready coding standards and config for AI coding agents — Claude Code, GitHub Copilot, Cursor, Windsurf, OpenCode, and anything reading the open AGENTS.md standard. Rules, commands, agents, skills, hooks, and MCP servers for Java/Spring Boot, Python/FastAPI, JS/React, PostgreSQL, MongoDB, Redis, Kafka, Docker, K8s, and AI/ML.
Descrizione
# AI Coding Agent Toolkit
<img width="1024" height="1024" alt="image" src="https://github.com/user-attachments/assets/362fbec4-a3f8-463e-aa98-11e50b895815" />
<div align="center">
[](LICENSE)
[](#whats-inside)
[](#skills-14-skill-packs)
[](https://github.com/Ashfaqbs/ai-coding-agent-toolkit)
[](https://github.com/Ashfaqbs/ai-coding-agent-toolkit/network/members)
[Quick Install](#quick-install) • [What's Inside](#whats-inside) • [Rules](#rules-9-files) • [Commands](#slash-commands-8-commands) • [Agents](#agents-5-agents) • [Skills](#skills-14-skill-packs) • [Other AI Tools](#other-ai-coding-tools) • [Contributing](CONTRIBUTING.md)
</div>
Production-ready coding standards and config for AI coding agents — backend-heavy full-stack developers. Pre-configured rules, slash commands, agents, skills, hooks, and MCP servers — covering Java 17 + Spring Boot 3, Python 3.12 + FastAPI, JavaScript (Express.js + React), PostgreSQL, MongoDB, Redis, Kafka, Flink, Docker, Kubernetes, and AI/ML workflows.
Drop it in, run the installer, and your AI coding agent of choice immediately understands your stack, enforces your standards, and works the way you work. The full experience (commands, agents, skills, hooks, MCP servers) is built around Claude Code, but the coding rules underneath aren't Claude-specific: `--ai` exports them for [GitHub Copilot, Cursor, Windsurf, OpenCode, and the open AGENTS.md standard](#other-ai-coding-tools) (which also covers OpenAI Codex, Google Jules, Zed, Warp, Aider, goose, and Amp) — pick the one line in [Quick Install](#quick-install) that matches what you actually run.
## Who This Is For
- Backend developers working with Java/Spring Boot, Python/FastAPI, or Node.js/Express
- Full-stack developers who also touch React frontends
- Engineers working with PostgreSQL, MongoDB, Redis, Kafka, or Flink
- Anyone building AI/ML pipelines (RAG, agents, MCP servers, vector databases)
- Developers who want their AI coding agent — Claude Code, Copilot, Cursor, Windsurf, OpenCode, or anything reading AGENTS.md — to follow real engineering standards, not generic defaults
## What's Inside
| Component | Count | What It Does |
|-----------|-------|--------------|
| **Rules** | 9 | Coding standards Claude follows on every response |
| **Slash Commands** | 8 | One-command workflows (`/plan`, `/tdd`, `/code-review`, etc.) |
| **Agents** | 5 | Specialized AI personas for planning, review, security, architecture, TDD |
| **Skills** | 14 | Deep domain knowledge packs (Spring Boot, Python, React, PostgreSQL, Kafka, etc.) |
| **Hooks** | 4 | Automated guardrails that run before/after tool use |
| **MCP Servers** | 4 | External tool integrations (docs lookup, memory, reasoning, GitHub) |
| **Examples** | 3 | Ready-to-use CLAUDE.md templates for your projects |
**Total: 47 components** working together to make Claude Code act like a senior engineer on your team.
## Before vs After
### Before (vanilla agent, no toolkit)
```
You: "Add a user registration endpoint"
Agent: *generates a basic endpoint with no validation, no error handling,
uses field injection, no tests, hardcoded values, no consideration
for your existing project patterns*
```
### After (with this toolkit)
```
You: "Add a user registration endpoint"
Agent: *reads your project's rules (CLAUDE.md/AGENTS.md/whichever your tool
reads), follows your naming conventions, uses constructor injection,
adds @Valid with proper DTOs, writes a Flyway migration, includes
unit + integration tests with Testcontainers, uses your custom
exception hierarchy, follows your git commit format, and warns you
about the missing rate limiter*
```
The difference is not magic — it's context. This toolkit gives whichever agent you use the same context you'd give a new developer joining your team. (The example above shows Claude Code's exact behavior with this toolkit installed; the same rules exported via `--ai` get you the same context in Copilot, Cursor, Windsurf, or OpenCode.)
---
## Quick Install
### Mac / Linux
```bash
git clone https://github.com/Ashfaqbs/ai-coding-agent-toolkit.git
cd ai-coding-agent-toolkit
chmod +x install.sh
./install.sh
```
### Windows (PowerShell)
```powershell
git clone https://github.com/Ashfaqbs/ai-coding-agent-toolkit.git
cd ai-coding-agent-toolkit
.\install.ps1
```
The installer:
- Copies all components to `~/.claude/`
- Backs up existing files before overwriting
- Merges hooks into your existing `settings.json`
- Skips `CLAUDE.md` if you already have one (won't overwrite your personal config)
### Selective Install (pick only the stacks you use)
By default the installer copies everything. If you don't use Java/Spring Boot, Python, or JS/React, install only the cross-stack rules/skills plus the stack(s) you actually use:
```bash
# Mac/Linux — see available groups
./install.sh --list
./install.sh --stacks=python-fastapi,ai-ml
# Windows (PowerShell)
.\install.ps1 -ListGroups
.\install.ps1 -Stacks python-fastapi,ai-ml
```
Groups: `general` (coding style, git workflow, testing, security, databases, infra, all slash commands, all agents — always installed), `java-springboot`, `python-fastapi`, `javascript-react`, `ai-ml`. Slash commands and agents are stack-neutral and always installed in full; only `rules/` and `skills/` are filtered. Filtering requires Node.js on Mac/Linux (falls back to installing everything if missing); the PowerShell installer filters natively.
Don't use any of the three languages this toolkit ships rules for? Install with `--stacks=` (no stack named) to get just the general rules/commands/agents, then add your own stack's rules/skills under `~/.claude/rules/` and `~/.claude/skills/` — see [Contributing](CONTRIBUTING.md) for the format, especially if you'd rather submit it back for others on your stack.
### Global vs. Project-Local Install
By default this installs globally to `~/.claude` — every project gets it. Pass `--local` / `-Local` to scope the install to the current repo instead (`./.claude/`, `./CLAUDE.md` from the blank project template, `./.mcp.json` at the repo root):
```bash
./install.sh --local --stacks=java-springboot # Mac/Linux
.\install.ps1 -Local -Stacks java-springboot # Windows
```
Combine freely with `--stacks`/`-Stacks` — e.g. a repo-local install with only the Java rules/skills, leaving your global `~/.claude` untouched.
### Other AI Coding Tools
This toolkit started as one person's Claude Code setup, but the rules themselves (coding standards for Java/Spring, Python/FastAPI, JS/React, databases, infra, git, testing, security) aren't Claude-specific. `--ai` / `-Ai` exports the selected rules (general + `--stacks`) into whichever tool you actually use:
| `--ai` value | Target tool(s) | What it writes |
|---|---|---|
| `claude` (default) | Claude Code | Full install: rules, commands, agents, skills, hooks, MCP config, CLAUDE.md |
| `copilot` | GitHub Copilot | `.github/copilot-instructions.md` (flattened rules) |
| `cursor` | Cursor | `.cursor/rules/<id>.mdc` — one file per rule, `alwaysApply: true` frontmatter |
| `windsurf` | Windsurf | `.windsurf/rules/<id>.md` — one file per rule (warns if a file exceeds Windsurf's ~6,000-char-per-file guidance) |
| `opencode` | OpenCode | `AGENTS.md` **plus** `.opencode/command/*.md` (commands, copied as-is — same `$ARGUMENTS` convention) and `.opencode/agent/*.md` (agents, as `mode: subagent`) |
| `agentsmd` | OpenAI Codex, Jules, Zed, Warp, Aider, goose, Amp — and a recognized fallback for Cursor/Windsurf/Copilot too | `AGENTS.md` — the open [agents.md](https://agents.md) standard that all of these already read |
```bash
./install.sh --ai=opencode --stacks=python-fastapi # Mac/Linux
.\install.ps1 -Ai opencode -Stacks python-fastapi # Windows
```
A few things worth knowing before you reach for one of these:
- **Every non-`claude` target always writes to the current repo**, regardless of `--local`/global — none of these tools have a user-level/global config the way Claude Code does.
- **Commands, agents, skills, hooks, and MCP config are skipped** for every target except `opencode` (which maps commands and agents too, since it's the one tool here with Claude-like extensibility) — printed explicitly as `SKIPPED`, never silently dropped. This is a v1 gap: contributions deepening any of these, or adding another tool, are welcome — see [Contributing](CONTRIBUTING.md).
- **There is no `--ai=chatgpt`.** Plain ChatGPT (the chat product) has no repo-level instructions file at all — only OpenAI's coding agent, Codex, does, and that's covered by `--ai=agentsmd`.
- **Cursor, Windsurf, and Copilot ("coding agent") all read `AGENTS.md` too**, per the standard's own adopter list — so `--ai=agentsmd` is a reasonable single-file choice if you don't need Cursor's per-rule activation modes or don't mind Windsurf's per-file size limit.
### Manual Install
If you prefer to cherry-pick, copy individual folders to `~/.claude/`:
```
~/.claude/
rules/ <- copy rules/*.md
commands/ <- copy commands/*.md
agents/ <- copy agents/*.md
skills/ <- copy skills/*/
settings.json <- merge hooks from hooks/settings.json
.mcp.json <- copy mcp/mcp-servers.json
CLAUDE.md <- copy examples/CLAUDE.md (customize it)
```
---
## Rules (9 files)
Rules are always-on instructions that Claude Code follows in every response. They live in `~/.claude/rules/` and are automatically loaded.
| File | Covers |
|------|--------|
| `coding-style.md` | Immutability, naming conventions, file organization, function design, error handling |
| `java-springboot.md` | Java 17 features, Spring Boot 3 standards, project structure, REST conventions, Redis, Kafka |
| `python-backend-ai.md` | FastAPI, Pydantic, SQLAlchemy 2.0, RAG pipelines, MCP/ADK agents, ML best practices |
| `javascript.md` | Express.js API patterns, React conventions, hooks, project structure |
| `databases.md` | PostgreSQL (migrations, indexes, UUIDs), MongoDB (embedding vs referencing), Redis (data structures, TTL, key naming) |
| `infra.md` | Docker (multi-stage builds), Kubernetes (probes, HPA, PDB), Kafka (topics, consumers, idempotency), Flink (state, checkpoints) |
| `git-workflow.md` | Conventional commits, branch strategy, PR process, what not to commit |
| `testing.md` | TDD workflow, 80% coverage target, JUnit/pytest/Jest patterns, test naming |
| `security.md` | Auth, secrets management, API security, data protection, container security |
### Example: What the Java Rule Does
When you ask Claude to write a Spring Boot service, it automatically:
- Uses Java 17 records for DTOs
- Applies constructor injection (no `@Autowired`)
- Uses `@ConfigurationProperties` with records (no `@Value`)
- Follows the correct package structure (`domain/`, `service/`, `controller/`, `dto/`)
- Adds `@Valid` on controller inputs
- Uses `@Transactional` on service methods
- Writes Flyway migrations instead of `ddl-auto`
No prompting needed. It just knows.
---
## Slash Commands (8 commands)
Slash commands are on-demand workflows you invoke with `/command-name` in Claude Code.
| Command | What It Does |
|---------|--------------|
| `/plan` | Creates a step-by-step implementation plan before writing code. Identifies affected files, risks, and complexity. |
| `/code-review` | Reviews uncommitted changes for security issues, code quality, and testing gaps. |
| `/tdd` | Drives test-driven development: RED (failing test) -> GREEN (minimal code) -> IMPROVE (refactor). |
| `/build-fix` | Incrementally fixes build errors one at a time until the build succeeds. |
| `/api-design` | Designs REST API endpoints with request/response schemas, error formats, and data models. |
| `/docker-setup` | Generates Dockerfile, docker-compose.yml, and .dockerignore by detecting your project stack. |
| `/system-design` | Walks through system design: requirements, architecture, data design, APIs, scaling, reliability. |
| `/db-schema` | Designs database schemas: identifies entities, picks the right DB, defines tables/collections, plans migrations. |
### Example: Using `/plan`
```
You: /plan Add order cancellation with inventory rollback
Claude:
## Implementation Plan: Order Cancellation
### Phase 1: Domain Changes
- Add `CANCELLED` to OrderStatus enum
- Add CancellationReason value object
- New Flyway migration V6__add_cancellation_fields.sql
### Phase 2: Service Layer
- OrderCancellationService with rollback logic
- InventoryService.rollback(orderId) method
- Kafka event: orders.order.cancelled
### Phase 3: API
- POST /api/v1/orders/{id}/cancel
- CancelOrderRequest record with reason field
### Phase 4: Tests
- Unit: cancellation service, inventory rollback
- Integration: full cancel flow with Testcontainers
- Edge cases: already cancelled, already shipped
### Risks
- Race condition: order shipped while cancellation in progress
- Partial rollback if inventory service fails mid-operation
### Estimated Complexity: Medium
Files affected: 8 | New files: 3 | Migration: Yes
```
---
## Agents (5 agents)
Agents are specialized AI personas with their own system prompts, tools, and reasoning models. They handle deeper analysis than slash commands.
| Agent | Model | What It Does |
|-------|-------|--------------|
| `planner` | Sonnet | Analyzes requirements, reads existing patterns, identifies files to change, produces phased implementation plans. Never writes code. |
| `code-reviewer` | Sonnet | Scans recent changes for bugs, logic errors, style violations, and stack-specific anti-patterns. Categorizes by severity. |
| `security-reviewer` | Opus | Checks code for hardcoded secrets, SQL injection, missing auth checks, XSS, CSRF, and stack-specific vulnerabilities. |
| `architect` | Opus | System design and architecture decisions. Analyzes options, explains trade-offs, recommends patterns for services and technology choices. |
| `tdd-guide` | Sonnet | TDD coach that ensures test-first development. Guides through RED/GREEN/IMPROVE cycles. Blocks implementation before tests exist. |
### How Agents Differ from Commands
Commands are scripts — they follow a fixed workflow. Agents are thinkers — they analyze your specific situation, adapt their approach, and provide nuanced feedback. Use commands for routine tasks, agents for decisions that need judgment.
---
## Skills (14 skill packs)
Skills are deep domain knowledge packs that activate contextually. When Claude detects you're working on a Spring Boot project, the relevant skills auto-load to provide patterns, examples, and best practices.
| Skill | Domain | What It Provides |
|-------|--------|-----------------|
| `springboot-patterns` | Java/Spring | REST API design, layered architecture, caching, async processing, logging patterns |
| `springboot-security` | Java/Spring | Auth/authz, validation, CSRF, secrets, security headers, rate limiting |
| `springboot-tdd` | Java/Spring | JUnit 5, Mockito, MockMvc, Testcontainers, JaCoCo coverage patterns |
| `java-coding-standards` | Java | Java 17 idioms, records, sealed classes, pattern matching, Optional usage |
| `jpa-patterns` | Java/DB | Entity design, relationships, query optimization, transactions, auditing, pagination |
| `postgres-patterns` | Database | Query optimization, schema design, indexing strategies, security best practices |
| `kafka-patterns` | Java/Messaging | Spring Kafka producers/consumers, manual offset commits, idempotent consumers, dead letter topics |
| `python-patterns` | Python | Pythonic idioms, PEP 8, type hints, dataclasses, best practices |
| `python-testing` | Python | pytest, TDD methodology, fixtures, mocking, parametrization, coverage |
| `frontend-patterns` | React/JS | React patterns, state management, performance optimization, UI best practices |
| `backend-patterns` | Node.js | API design, database optimization, server-side patterns for Express/Next.js |
| `iterative-retrieval` | AI/Agents | Progressive context retrieval for solving the subagent context problem in RAG systems |
| `eval-harness` | AI/Dev | Eval-driven development (EDD) framework — define success criteria before implementation |
| `security-review` | Security | Comprehensive security checklist: secrets, input validation, SQLi, XSS, CSRF, auth |
---
## Hooks (4 hooks)
Hooks are automated guardrails that run before or after Claude uses a tool. They catch mistakes in real-time without you having to remember to check.
### Pre-Tool Hooks (run before execution)
| Hook | Trigger | Action |
|------|---------|--------|
| Block dangerous commands | `git push --force`, `git reset --hard`, `rm -rf` | **Blocks execution** with error message |
| Git push reminder | Any `git push` | Warns to review changes first |
### Post-Tool Hooks (run after file edits)
| Hook | Trigger | Action |
|------|---------|--------|
| Java: System.out.println | Editing `.java` files | Warns and suggests SLF4J logger |
| Java: @Autowired | Editing `.java` files | Warns and suggests constructor injection |
| Python: print() | Editing `.py` files | Warns and suggests logging module |
| JS/TS: console.log | Editing `.js/.jsx/.ts/.tsx` files | Warns and suggests removing before commit |
These hooks run automatically. You don't invoke them — they protect you silently.
---
## MCP Servers (4 servers)
MCP (Model Context Protocol) servers extend Claude Code with external tool capabilities.
| Server | What It Does | Cost |
|--------|-------------|------|
| `context7` | Looks up library documentation. Resolves to latest docs instead of stale training data. | Free |
| `memory` | Persistent memory across sessions. Remembers project decisions, preferences, and context. | Free |
| `sequential-thinking` | Step-by-step reasoning for complex problems. System design, debugging, architecture decisions. | Free |
| `github` | GitHub integration — PRs, issues, repos, code search. | Free (needs token) |
### Setup
After installing, edit `~/.claude/.mcp.json` and replace `<YOUR_GITHUB_TOKEN>` with a [GitHub personal access token](https://github.com/settings/tokens) (if you want GitHub integration).
The other 3 servers work out of the box with no configuration.
---
## Examples (3 templates)
| File | What It Is |
|------|-----------|
| `examples/CLAUDE.md` | Global user-level config. Defines your preferences, tech stack, and links to rules. Install to `~/.claude/CLAUDE.md`. |
| `examples/CLAUDE-TEMPLATE.md` | Blank project-level template. Copy to your project root as `CLAUDE.md` and fill in the blanks. |
| `examples/sample-springboot-CLAUDE.md` | Filled-in example for a Spring Boot order management service. Shows what a good project CLAUDE.md looks like. |
### The CLAUDE.md System
Claude Code reads `CLAUDE.md` files at two levels:
1. **Global** (`~/.claude/CLAUDE.md`) — Your personal preferences, tech stack, coding style. Loaded for every project.
2. **Project** (`./CLAUDE.md` in project root) — Project-specific context: how to run, structure, key decisions, environment variables, what not to touch.
The global config tells Claude who you are. The project config tells Claude what you're working on. Together, they give Claude the full picture.
---
## How to Customize
### Add your own rules
Create a new `.md` file in `~/.claude/rules/`:
```markdown
# My Custom Rule
## Always
- Use tabs, not spaces
- Prefer composition over inheritance
```
### Add your own slash commands
Create a new `.md` file in `~/.claude/commands/`:
```markdown
# My Custom Command
When I invoke this command:
1. Do step one
2. Do step two
3. Return the result in this format
```
### Modify existing components
Every file is plain Markdown. Open it, edit it, save it. Changes take effect on the next Claude Code session.
### Remove components you don't need
Delete the file. If you don't use Python, remove `python-backend-ai.md` from rules and `python-patterns/` and `python-testing/` from skills.
---
## Repository Structure
```
ai-coding-agent-toolkit/
├── README.md
├── LICENSE # MIT
├── .gitignore
│
├── rules/ # 9 always-on coding standards
│ ├── coding-style.md
│ ├── java-springboot.md
│ ├── python-backend-ai.md
│ ├── javascript.md
│ ├── databases.md
│ ├── infra.md
│ ├── git-workflow.md
│ ├── testing.md
│ └── security.md
│
├── commands/ # 8 slash commands
│ ├── plan.md
│ ├── code-review.md
│ ├── tdd.md
│ ├── build-fix.md
│ ├── api-design.md
│ ├── docker-setup.md
│ ├── system-design.md
│ └── db-schema.md
│
├── agents/ # 5 specialized AI agents
│ ├── planner.md
│ ├── code-reviewer.md
│ ├── security-reviewer.md
│ ├── architect.md
│ └── tdd-guide.md
│
├── hooks/ # Automated guardrails
│ └── settings.json
│
├── mcp/ # MCP server configs
│ └── mcp-servers.json
│
├── skills/ # 14 domain knowledge packs
│ ├── springboot-patterns/
│ ├── springboot-security/
│ ├── springboot-tdd/
│ ├── java-coding-standards/
│ ├── jpa-patterns/
│ ├── postgres-patterns/
│ ├── kafka-patterns/
│ ├── python-patterns/
│ ├── python-testing/
│ ├── frontend-patterns/
│ ├── backend-patterns/
│ ├── iterative-retrieval/
│ ├── eval-harness/
│ └── security-review/
│
├── examples/ # Templates and examples
│ ├── CLAUDE.md
│ ├── CLAUDE-TEMPLATE.md
│ └── sample-springboot-CLAUDE.md
│
├── install.sh # Mac/Linux installer
└── install.ps1 # Windows installer
```
---
## Contributing
New rules, commands, agents, or skills are welcome — especially for stacks not covered yet (Go, Rust, .NET, other frontend frameworks). See [CONTRIBUTING.md](CONTRIBUTING.md) for the format each component type follows and how to submit one.
## Credits
Built on patterns from:
- [everything-claude-code](https://github.com/anthropics/everything-claude-code) — Anthropic's official collection of Claude Code configurations, skills, and community patterns
- [Claude Code Documentation](https://docs.anthropic.com/en/docs/claude-code) — Official docs for rules, commands, agents, hooks, MCP, and skills
## License
MIT — use it, fork it, modify it, share it.
Installazione
Installa la skill da https://github.com/Ashfaqbs/ai-coding-agent-toolkitQuesta skill non è pubblicata sul registro ClawHub. Incolla il prompt nel tuo agente di coding — Claude Code, Cursor, Codex — e installerà la skill direttamente dal repository sorgente.
Apri il repository