Merge pull request #67 from olehsvyrydov/feat/language-skills-java-ts

Add auto-loading java and typescript language skills; split the Spring reference

Author: olehsvyrydov

CHANGELOG.md

@@ -6,6 +6,7 @@ This file records all notable changes to the project. Versioning roughly follows
 
 ### Added
 - **Language skills: `rust` and `sql`** (`claude/skills/development/languages/`) — a deliberate amendment to "stacks are references". References never auto-load, and language standards must apply whenever that language is being written, with no role command invoked — so language expertise becomes a first-class skill whose frontmatter description triggers from context (a `.rs` file, a migration, an embedded query). No persona and no slash command; `/be`, `/dba`, `/rev` and `/arch` route into the one copy. Rust carries checked-in toolchain/lint/deny policy, ownership-driven architecture (core crate + thin shells, state machines, newtypes), the error doctrine with a failure-table method, tokio task ownership and cancellation, rusqlite embedding, deterministic testing (fixtures that refuse real credentials), boundary security, and a reviewer pass. SQL carries parameterized-only, versioned migrations with expand-migrate-contract, EXPLAIN-before-merge, a scratch-container empirical check, dialect branches for PostgreSQL 18, MySQL 8.4/9.7, Oracle 26ai and SQLite, and a reviewer pass.
+- **Language skills: `java` and `typescript`** — the second pair, targeting JVM and Node/browser work. Java carries record/sealed-type modelling with exhaustive switches, JSpecify `@NullMarked` + NullAway as a build error, immutability doctrine, the JEP-491-corrected virtual-thread guidance, ScopedValue over ThreadLocal, ArchUnit rules as the executable form of approved boundaries, PIT mutation thresholds, Testcontainers-first integration testing, and boundary security — with complete Gradle/Maven wiring in a build-and-quality-gates reference. TypeScript carries the strictest-profile checked-in tsconfig, discriminated unions with exhaustiveness, branded types, parse-don't-validate with Zod at every I/O edge (env read in exactly one module), ESM/package discipline, typescript-eslint with the promise rules as errors, and Vitest/MSW/fast-check testing — with complete checked-in templates. The backend role's `java-expertise.md` splits: the language half moves to the `java` skill, the Spring half stays and gains a Spring Boot 4 standards block; the frontend role's React reference points its language-level TypeScript section at the `typescript` skill.
 - **`/arch` design-for-predictability reference** — the ARCH_APPROVED deliverables that make reviews find decisions instead of surprises, produced before implementation: boundary contract sheets (where the Done rule's named enforcing symbols are born), state tables with no blank cells, lightweight FMEA over a fixed failure-class checklist, a test-case table whose negative rows must at least match its positive rows, blast-radius notes for shared contracts, and declared extension points. Proportional: contract sheet + test-case table on the standard track, all six on full.
 
 - **CI.** The skills here are markdown: nothing compiles and no test suite runs, so a defect stays invisible until someone reads the exact line. Every gate was previously run by hand, which means it was run when someone remembered — and the record of what shipped was reconciled against the tree only after it had drifted nine behind. Three jobs now run on every pull request: `scripts/validate-framework.py`, `claude plugin validate` (which needs no credentials), and `install.sh --dry-run --editors=all`.

CLAUDE.md

@@ -4,7 +4,7 @@ This file provides context to Claude Code when working in this repository.
 
 ## Project Purpose
 
-This is a **reusable AI agent-team framework** — 40 agent skills (a 15-agent core team, optional specialists, auto-loading language skills, and the cross-cutting process skills that sit at the top level of `claude/skills/`, including the `workflow-engine`), a proportional dev `workflow.yaml`, document templates, and the `install.sh` installer. Each skill file represents a team member with deep domain expertise. The skills are installed globally and used by every project. It is vendor-neutral and OSS-first, working in Claude Code / Cursor / Kiro / VS Code.
+This is a **reusable AI agent-team framework** — 42 agent skills (a 15-agent core team, optional specialists, auto-loading language skills, and the cross-cutting process skills that sit at the top level of `claude/skills/`, including the `workflow-engine`), a proportional dev `workflow.yaml`, document templates, and the `install.sh` installer. Each skill file represents a team member with deep domain expertise. The skills are installed globally and used by every project. It is vendor-neutral and OSS-first, working in Claude Code / Cursor / Kiro / VS Code.
 
 Its sibling agent-memory runtime — **Praxis** — lives in its own separate repository and consumes this shared agent layer, as does a separate governed knowledge backend. See `ARCHIVE.md` for the dashboard product that was previously carried here and set aside.
 
@@ -21,10 +21,10 @@ ai-dev-team/
 │   ├── CLAUDE.md          # Global instructions for Claude Code
 │   ├── TEAM_WORKFLOW.md   # Complete team workflow documentation
 │   │
-│   ├── skills/            # 40 agent skills: 15-agent core team + specialists + language + process skills
+│   ├── skills/            # 42 agent skills: 15-agent core team + specialists + language + process skills
 │   │   ├── management/    # Product Owner, Scrum Master, Business Analyst
 │   │   ├── architecture/  # Solution Architect, GraphQL
-│   │   ├── development/   # Backend, Frontend, Native mobile, Languages (Rust, SQL — auto-loading)
+│   │   ├── development/   # Backend, Frontend, Native mobile, Languages (Rust, Java, TypeScript, SQL — auto-loading)
 │   │   ├── quality/       # Reviewers, Testers, Verify auditor
 │   │   ├── operations/    # DevOps, SecOps, MLOps, SRE
 │   │   ├── design/        # UI Designer, UX Research
@@ -103,7 +103,7 @@ Gates fire **proportionally** (by change-class / trigger / preset) via the `work
 - **Version**: 5.2.0 (see `CHANGELOG.md`)
 - **Release Date**: 2026-08-03
 - **Distribution**: Claude Code plugin (preferred; `version` omitted so the commit SHA is the version) or the universal `install.sh` for Cursor / Kiro / VS Code
-- **Skills**: 40 (15-agent core team + optional specialists + auto-loading language skills + cross-cutting process skills; frameworks as references)
+- **Skills**: 42 (15-agent core team + optional specialists + auto-loading language skills + cross-cutting process skills; frameworks as references)
 - **Commands**: 50 slash commands
 - **Templates**: 6 document templates
 - **Backends**: pluggable adapters — file-based by default; Jira/Confluence/OpenMemory/Penpot/etc. optional

CONTRIBUTING.md

@@ -22,7 +22,7 @@ claude/
 ```
 
 Key ideas:
-- **Roles are agents; technology stacks are `references/` — and core languages are knowledge skills.** A role agent (e.g. `/be`) detects the project's stack and loads `references/<stack>.md` — we don't ship one agent per framework. The deliberate exception is `claude/skills/development/languages/`: language expertise (Rust; SQL with Postgres/MySQL/Oracle/SQLite branches) is a first-class skill, because references never auto-load and language standards must apply whenever that language is being written — with no role command invoked. Language skills have no persona and no slash command; role agents route into them, and each body of knowledge exists in exactly one place. See `claude/skills/disambiguation.md`.
+- **Roles are agents; technology stacks are `references/` — and core languages are knowledge skills.** A role agent (e.g. `/be`) detects the project's stack and loads `references/<stack>.md` — we don't ship one agent per framework. The deliberate exception is `claude/skills/development/languages/`: language expertise (Rust, Java, TypeScript; SQL with Postgres/MySQL/Oracle/SQLite branches) is a first-class skill, because references never auto-load and language standards must apply whenever that language is being written — with no role command invoked. Language skills have no persona and no slash command; role agents route into them, and each body of knowledge exists in exactly one place. See `claude/skills/disambiguation.md`.
 - **Progressive disclosure.** Keep `SKILL.md` under ~500 lines; move depth into `references/`. The frontmatter `description` is the always-in-context "menu" the model scans, so keep it sharp and enumerate what the agent covers.
 - **OSS-first, no lock-in.** Defaults need zero paid accounts; Jira/Confluence/MCP backends are optional overlays enabled in `workflow.yaml`.
 

README.md

@@ -2,15 +2,15 @@
 
 ![Claude Code](https://img.shields.io/badge/Claude%20Code-ready-6E56CF) ![Cursor](https://img.shields.io/badge/Cursor-ready-111111) ![Kiro](https://img.shields.io/badge/Kiro-ready-9B59B6) ![VS Code](https://img.shields.io/badge/VS%20Code-ready-007ACC) ![License: MIT](https://img.shields.io/badge/License-MIT-green) ![Stars](https://img.shields.io/github/stars/olehsvyrydov/AI-development-team?style=social)
 
-> **A reusable AI agent-team framework for your editor.** 40 agent skills (a 15-agent core team + optional specialists + auto-loading language skills + cross-cutting process skills) plus a `workflow-engine` and an **enforced, proportional workflow** with approval gates — *process, not prompts*. Installs as a **Claude Code plugin**, or via the universal installer for Cursor, Kiro & VS Code. Open-source, no lock-in, free by default.
+> **A reusable AI agent-team framework for your editor.** 42 agent skills (a 15-agent core team + optional specialists + auto-loading language skills + cross-cutting process skills) plus a `workflow-engine` and an **enforced, proportional workflow** with approval gates — *process, not prompts*. Installs as a **Claude Code plugin**, or via the universal installer for Cursor, Kiro & VS Code. Open-source, no lock-in, free by default.
 
 ```
 /po → /arch → /secops → [/fin] → [/legal] → [/ui] → /fe | /be → /rev → /qa + /e2e → /verify
 ```
 
 The framework is a portable agent layer you install once and use across every project. It ships four things:
 
-- **Agent skills** (`claude/skills/`) — lean `SKILL.md` personas that load deep `references/` on demand; tech stacks (React/Angular/Vue, Java/Kotlin/Python/PHP, …) are references the role *self-routes* to, not separate agents. Core languages (Rust; SQL with Postgres/MySQL/Oracle/SQLite branches) are the deliberate exception: knowledge skills in `claude/skills/development/languages/` that **auto-load from context** whenever that language is written or reviewed — no persona, no command.
+- **Agent skills** (`claude/skills/`) — lean `SKILL.md` personas that load deep `references/` on demand; tech stacks (React/Angular/Vue, Java/Kotlin/Python/PHP, …) are references the role *self-routes* to, not separate agents. Core languages (Rust, Java, TypeScript; SQL with Postgres/MySQL/Oracle/SQLite branches) are the deliberate exception: knowledge skills in `claude/skills/development/languages/` that **auto-load from context** whenever that language is written or reviewed — no persona, no command.
 - **The `workflow-engine`** — a skill that classifies each change and **refuses** to skip a required gate.
 - **`workflow.yaml`** — a versioned workflow definition, right-sized to the change via `solo` → `small-team` → `regulated` presets.
 - **Distribution** — a Claude Code **plugin** (declare it once per project; the commit SHA is the version, so every push is an update), or **`install.sh`**, which wires the skills, commands and templates into whichever editor(s) you use.
@@ -185,13 +185,13 @@ generated at the destination:
 ├── CLAUDE.md                    # generated pointer (TDD workflow, approval gates)
 ├── TEAM_WORKFLOW.md             # Complete team process documentation
 │
-├── skills/                      # 40 agent skill files (15 core + specialists + language + process skills)
+├── skills/                      # 42 agent skill files (15 core + specialists + language + process skills)
 │   ├── management/              # Product Owner, Scrum Master, Business Analyst
 │   ├── architecture/            # Solution Architect, GraphQL Developer
 │   ├── development/
 │   │   ├── backend/             # Java/Spring, Kotlin, PHP/Laravel, Python/FastAPI
 │   │   ├── frontend/            # React/Next.js, Angular, Vue, Flutter
-│   │   ├── languages/           # Rust, SQL (auto-loading knowledge skills, no persona)
+│   │   ├── languages/           # Rust, Java, TypeScript, SQL (auto-loading knowledge skills, no persona)
 │   │   └── mobile/              # Native iOS/Android
 │   ├── quality/
 │   │   ├── review/              # Full-stack, Backend, Frontend, PHP reviewers

claude/AGENTS.md

@@ -2,7 +2,7 @@
 
 > _Mirrors `CLAUDE.md` so editors that read `AGENTS.md` (Cursor, Kiro, VS Code) get identical guidance. References to "Claude Code" apply to your assistant._
 
-A team of 40 skills (a 15-agent core team + optional specialists, plus auto-loading language skills and cross-cutting process skills) + an enforced, proportional dev workflow. Open-source, vendor-neutral, works in Claude Code / Cursor / Kiro / VS Code, free by default.
+A team of 42 skills (a 15-agent core team + optional specialists, plus auto-loading language skills and cross-cutting process skills) + an enforced, proportional dev workflow. Open-source, vendor-neutral, works in Claude Code / Cursor / Kiro / VS Code, free by default.
 
 > **Nothing loads this file automatically.** `install.sh` deploys only `skills/`, `commands/`,
 > `templates/` and `workflow/`, and generates its own pointer file at the destination; a plugin
@@ -43,7 +43,7 @@ Native files by default. Optional OSS memory MCP (OpenMemory / mem0). No memory
 
 Two special-purpose agents sit outside the core 15: `/verify` (completion auditor / workflow gate) and `/kai` (self-improving meta-agent).
 
-Optional specialists (AI/LLM, Data, DBA, SRE, MLOps, UX research, Performance, Native mobile, Technical writer (`/tw`), …) load on demand. **Technology stacks are not separate agents** — a role agent detects the project's stack and loads the matching `references/<stack>.md` (Angular/Vue/Flutter/JavaFX → `/fe`; Kotlin/FastAPI/Laravel/Quarkus/Kafka/HMRC → `/be`; GraphQL → `/arch`; Terraform → `/devops`; Cucumber → `/e2e`; UK law/tax → `/legal`,`/fin`). The deliberate exception: **core languages are knowledge skills** — Rust and SQL (Postgres/MySQL/Oracle/SQLite dialect branches) live in `skills/development/languages/` and auto-load from context whenever that language is written or reviewed; no persona, no command, and the role agents route into them. Full roster: `/agents`. Role commands are standard; persona aliases invoke the same agent.
+Optional specialists (AI/LLM, Data, DBA, SRE, MLOps, UX research, Performance, Native mobile, Technical writer (`/tw`), …) load on demand. **Technology stacks are not separate agents** — a role agent detects the project's stack and loads the matching `references/<stack>.md` (Angular/Vue/Flutter/JavaFX → `/fe`; Kotlin/FastAPI/Laravel/Quarkus/Kafka/HMRC → `/be`; GraphQL → `/arch`; Terraform → `/devops`; Cucumber → `/e2e`; UK law/tax → `/legal`,`/fin`). The deliberate exception: **core languages are knowledge skills** — Rust, Java, TypeScript, and SQL (Postgres/MySQL/Oracle/SQLite dialect branches) live in `skills/development/languages/` and auto-load from context whenever that language is written or reviewed; no persona, no command, and the role agents route into them. Full roster: `/agents`. Role commands are standard; persona aliases invoke the same agent.
 
 ## Git
 Branch `feature/<KEY>-desc` · commit `<KEY>: message` · PR `<KEY>: title`. Run tests before committing.

claude/CLAUDE.md

@@ -1,6 +1,6 @@
 # AI Development Team
 
-A team of 40 skills (a 15-agent core team + optional specialists, plus auto-loading language skills and cross-cutting process skills) + an enforced, proportional dev workflow. Open-source, vendor-neutral, works in Claude Code / Cursor / Kiro / VS Code, free by default.
+A team of 42 skills (a 15-agent core team + optional specialists, plus auto-loading language skills and cross-cutting process skills) + an enforced, proportional dev workflow. Open-source, vendor-neutral, works in Claude Code / Cursor / Kiro / VS Code, free by default.
 
 > **Nothing loads this file automatically.** `install.sh` deploys only `skills/`, `commands/`,
 > `templates/` and `workflow/`, and generates its own pointer file at the destination; a plugin
@@ -54,7 +54,7 @@ Native files by default. Optional OSS memory MCP (OpenMemory / mem0). No memory
 
 Two special-purpose agents sit outside the core 15: `/verify` (completion auditor / workflow gate) and `/kai` (self-improving meta-agent).
 
-Optional specialists (AI/LLM, Data, DBA, SRE, MLOps, UX research, Performance, Native mobile, Technical writer (`/tw`), …) load on demand. **Technology stacks are not separate agents** — a role agent detects the project's stack and loads the matching `references/<stack>.md` (Angular/Vue/Flutter/JavaFX → `/fe`; Kotlin/FastAPI/Laravel/Quarkus/Kafka/HMRC → `/be`; GraphQL → `/arch`; Terraform → `/devops`; Cucumber → `/e2e`; UK law/tax → `/legal`,`/fin`). The deliberate exception: **core languages are knowledge skills** — Rust and SQL (Postgres/MySQL/Oracle/SQLite dialect branches) live in `skills/development/languages/` and auto-load from context whenever that language is written or reviewed; no persona, no command, and the role agents route into them. Full roster: `/agents`. Role commands are standard; persona aliases invoke the same agent.
+Optional specialists (AI/LLM, Data, DBA, SRE, MLOps, UX research, Performance, Native mobile, Technical writer (`/tw`), …) load on demand. **Technology stacks are not separate agents** — a role agent detects the project's stack and loads the matching `references/<stack>.md` (Angular/Vue/Flutter/JavaFX → `/fe`; Kotlin/FastAPI/Laravel/Quarkus/Kafka/HMRC → `/be`; GraphQL → `/arch`; Terraform → `/devops`; Cucumber → `/e2e`; UK law/tax → `/legal`,`/fin`). The deliberate exception: **core languages are knowledge skills** — Rust, Java, TypeScript, and SQL (Postgres/MySQL/Oracle/SQLite dialect branches) live in `skills/development/languages/` and auto-load from context whenever that language is written or reviewed; no persona, no command, and the role agents route into them. Full roster: `/agents`. Role commands are standard; persona aliases invoke the same agent.
 
 ## Git
 Branch `feature/<KEY>-desc` · commit `<KEY>: message` · PR `<KEY>: title`. Run tests before committing.