Merge pull request #66 from olehsvyrydov/feat/language-skills-rust-sql

Add auto-loading rust and sql language skills, and the architect's predictability deliverables

Author: olehsvyrydov

CHANGELOG.md

@@ -5,9 +5,15 @@ This file records all notable changes to the project. Versioning roughly follows
 ## [Unreleased]
 
 ### 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.
+- **`/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`.
 - **`scripts/validate-framework.py`** — seven gates, each covering something that has actually broken in this repository: a `SKILL.md` whose frontmatter does not parse and therefore loads with empty metadata and can never auto-trigger; malformed plugin JSON, or a `version` key reappearing where it is omitted on purpose; a documented count that no longer matches the tree; a relative link pointing at nothing; a credential-shaped file being tracked in a public repository; a reference to a mechanism that was removed; and a backend product named inside a skill rather than in its adapter reference. Every gate was verified to fail on its own defect and pass when clean, because a gate that cannot fail is decoration.
 
+### Removed
+- **`/be`'s project-specific Rust reference** — replaced by the universal `rust` language skill. The old file named one private project's modules, paths and error codes, violating the framework's own universal-knowledge rule; the project-specific half now lives in that project's own repository as a project-local skill.
+
 ## [5.2.0] — 2026-08-03
 
 Distribution moves from copying files to a versioned plugin, and three skills that documented

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** — 38 agent skills (a 15-agent core team, optional specialists, 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** — 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.
 
 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/            # 38 agent skills: 15-agent core team + specialists + process skills
+│   ├── skills/            # 40 agent skills: 15-agent core team + specialists + language + process skills
 │   │   ├── management/    # Product Owner, Scrum Master, Business Analyst
 │   │   ├── architecture/  # Solution Architect, GraphQL
-│   │   ├── development/   # Backend (Java/Kotlin/Python), Frontend (React/Angular/Vue/Flutter), Native mobile
+│   │   ├── development/   # Backend, Frontend, Native mobile, Languages (Rust, 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**: 38 (15-agent core team + optional specialists + cross-cutting process skills; tech stacks as references)
+- **Skills**: 40 (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/`.** A role agent (e.g. `/be`) detects the project's stack and loads `references/<stack>.md` — we don't ship one agent per framework. 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; 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`.
 
@@ -45,6 +45,15 @@ Key ideas:
 3. Add a row to `claude/commands/agents.md` (Core or Specialists) and, if it overlaps another agent, a line in `claude/skills/disambiguation.md`.
 4. If the agent has a lot of depth, put it in `references/` and add a references index + (for multi-stack roles) a "Stack selection" router.
 
+## Add a language skill
+
+Language skills live in `claude/skills/development/languages/<lang>/` and differ from agents: no persona, no command file, and a frontmatter `description` written to **auto-trigger from context** — name the concrete file signals (extensions, manifests, tool failures) first, and end with a NOT-clause so it doesn't fire spuriously.
+
+1. Create `claude/skills/development/languages/<lang>/SKILL.md` (+ `references/` for depth, including a `<lang>-review.md` pass for `/rev`).
+2. Point the owning role agents' router tables at it (`/be`, `/fe`, `/dba`, `/rev` as applicable) — the role routes to the one copy; it does not duplicate it.
+3. Add a line to `claude/skills/disambiguation.md` and to the language-skills note in `claude/commands/agents.md`.
+4. Update the skill-count claim sites (G3 lists them if you miss one). No command step — loading from context is the point.
+
 ## Quality bar
 
 - `SKILL.md` < ~500 lines; deep content in `references/`.

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.** 38 agent skills (a 15-agent core team + optional specialists + 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.** 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.
 
 ```
 /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.
+- **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.
 - **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,12 +185,13 @@ generated at the destination:
 ├── CLAUDE.md                    # generated pointer (TDD workflow, approval gates)
 ├── TEAM_WORKFLOW.md             # Complete team process documentation
 │
-├── skills/                      # 38 agent skill files (15 core + specialists + process skills)
+├── skills/                      # 40 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)
 │   │   └── mobile/              # Native iOS/Android
 │   ├── quality/
 │   │   ├── review/              # Full-stack, Backend, Frontend, PHP reviewers
@@ -442,38 +443,40 @@ invent them.
 
 1. Create a skill directory under the appropriate category:
    ```
-   claude/skills/development/backend/rust/rust-developer/SKILL.md
+   claude/skills/development/backend/go/go-developer/SKILL.md
    ```
 
 2. Follow the SKILL.md format (YAML frontmatter + structured Markdown sections):
    ```yaml
    ---
-   name: rust-developer
-   description: "Senior Rust Developer with 8+ years systems programming experience"
+   name: go-developer
+   description: "Senior Go Developer with 8+ years systems programming experience"
    ---
 
-   # Rust Developer
+   # Go Developer
 
    ## Trigger
-   Use when working with Rust code, systems programming, or performance-critical services.
+   Use when working with Go code, services, or CLI tooling.
 
    ## Context
-   You are a Senior Rust Developer...
+   You are a Senior Go Developer...
 
    ## Expertise
-   ### Rust 2024 Edition
-   - Ownership, borrowing, lifetimes
+   ### Modern Go
+   - Goroutines, channels, context propagation
    ...
 
    ## Anti-Patterns
-   - Never use `unwrap()` in production code
+   - Never discard a returned error
    ...
    ```
 
-3. Create a slash command in `claude/commands/rust.md`
+3. Create a slash command in `claude/commands/go.md`
 
 4. Re-install / update: `./install.sh` (idempotent)
 
+For a core **language** rather than a role, use the knowledge-skill pattern instead — see `claude/skills/development/languages/` (Rust, SQL): no persona, no command; the frontmatter description auto-triggers from context and the role agents route into it. The recipe is in `CONTRIBUTING.md` under "Add a language skill".
+
 See: [Skill Extension Guide](docs/skill-extension-guide.md)
 
 ### Adding a New Technology to an Existing Agent

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 38 skills (a 15-agent core team + optional specialists, plus 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 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.
 
 > **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`). 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 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 38 skills (a 15-agent core team + optional specialists, plus 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 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.
 
 > **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`). 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 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.