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">

Quick Install • What's Inside • Rules • Commands • Agents • Skills • Other AI Tools • Contributing

</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 (which also covers OpenAI Codex, Google Jules, Zed, Warp, Aider, goose, and Amp) — pick the one line in 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

git clone https://github.com/Ashfaqbs/ai-coding-agent-toolkit.git
cd ai-coding-agent-toolkit
chmod +x install.sh
./install.sh

Windows (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:

# 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 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):

./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 standard that all of these already read |

./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.
• 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 | Increm