{"slug": "agile-v-turning-ai-agents-into-verifiable-engineering-systems", "title": "Agile V: Turning AI Agents into Verifiable Engineering Systems", "summary": "Agile V has released a framework that transforms unreliable AI agents into verifiable engineering systems by enforcing formal traceability, independent verification, and human gates before deployment. The framework requires every line of code to link to requirement, artifact, and test case IDs, and halts agents when requirements are unclear to prevent silent assumptions and hallucinations. This addresses the catastrophic failures of AI agents that generate code without requirements, skip testing, and deploy autonomously to production.", "body_md": "**AI agents hallucinate.** They generate code without requirements, skip testing, make silent assumptions, and deploy to production without approval. Great for demos. **Catastrophic for real products.**\n\nTransform unreliable AI agents into **Verifiable Engineering Systems** with:\n\n- ✅\n**Formal Traceability**— Every line of code links to`REQ-XXXX`\n\n→`ART-XXXX`\n\n→`TC-XXXX`\n\n- ✅\n**Independent Verification**— Red Team Verifier tests what Build Agent creates (no self-grading) - ✅\n**Hardware Awareness**— Agents ask about RAM/CPU/GPU before optimizing (no \"works on my machine\") - ✅\n**Human Gates**— Evidence Summaries before deployments (no autonomous production releases) - ✅\n**Halt on Ambiguity**— Agents stop and ask when requirements are unclear (no silent assumptions) - ✅\n**Compliance-Ready**— Auto-generates ISO 9001, ISO 27001, GxP artifacts from day 1 - ✅\n**Multi-Platform**— Works with Claude Code, Cursor, VS Code, GitHub Copilot\n\n**Claude Code:**\n\n```\n/plugin install agile-v-skills\n```\n\n**Cursor:**\n\n```\n# Copy project rules to enable auto-apply\ncp -r .cursor/rules/ /path/to/your/project/.cursor/\n```\n\n**VS Code / GitHub Copilot:**\n\n```\n# Copy skills to global directory\ncp -r agile-v-core/ ~/.copilot/skills/\ncp -r build-agent/ ~/.copilot/skills/\n```\n\n👉 **See Installation Guide for detailed platform-specific instructions**\n\n```\nYou: \"Add user authentication\"\n\nAgent: ⚠️ HALT CONDITION: No requirement specification found\n\nBefore implementing, I'll invoke the Requirement Architect to:\n1. Decompose \"user authentication\" into formal requirements\n2. Define acceptance criteria\n3. Identify security and compliance constraints\n\n[Requirement Architect creates REQ-0001, REQ-0002...]\n\nBuild Agent: ✓ Implementation complete (ART-0001 → REQ-0001)\nRed Team Verifier: Testing independently...\n  - Found 2 security issues Build Agent missed\n  - SECURITY-001: No max password length (DoS risk)\n  \n[Build Agent fixes issues based on Red Team feedback]\n\nRed Team Verifier: ✓ All tests pass\nAgent: Ready for Human Gate approval\n```\n\n**Result:** Production-ready code with full traceability and independent verification.\n\n| Feature | Typical AI Agents | Agile V Framework |\n|---|---|---|\nTraceability |\n❌ Code appears without requirements | ✅ Every artifact links to REQ-XXXX |\nVerification |\n❌ Self-tests own code (confirmation bias) | ✅ Independent Red Team Verifier |\nHardware |\n❌ Assumes unlimited resources | ✅ Validates RAM/CPU/GPU constraints |\nDeployment |\n❌ Autonomous production pushes | ✅ Human Gates with Evidence Summaries |\nAmbiguity |\n❌ Silent assumptions, hallucinations | ✅ Halts and asks clarifying questions |\nCompliance |\n❌ Manual audit prep (weeks) | ✅ Auto-generated ISO/GxP artifacts |\nMulti-Cycle |\n❌ Fresh start each iteration | ✅ Change Requests, version control, regression tests |\n\nThis repository contains the official collection of **Agent Skills** for the Agile V™ framework. These skills transform standard LLMs into specialized engineering agents capable of building, verifying, and auditing complex systems with mathematical rigor.\n\nThe [Agile V™ Manifesto](https://agile-v.org) provides the philosophy; this repository provides the **mechanics**.\n\nBy deploying these skills, you move away from \"unstructured prompting\" and toward a formal **Autonomous Quality Management System (AQMS)**. Every skill in this library is built to enforce:\n\n**Traceability:** Every action is linked to a Requirement ID.**Verification:** No artifact is created without a \"Red Team\" challenge.**Human Curation:** Automated stops at critical \"Human Gates.\"\n\nThe skills are organized following the **Agile V™ Infinity Loop**. Each skill lives at the root level (or under `domains/`\n\nfor language-specific extensions) for ease of use. You can reference skills directly with simple paths like `./agile-v-core/SKILL.md`\n\nwhen configuring Cursor or other agent tools.\n\n```\n├── agile-v-core/           # Foundation: Core philosophy and operational logic\n├── requirement-architect/  # Left Side: Intent and decomposition\n├── logic-gatekeeper/       # Left Side: Ambiguity and constraint validation\n├── build-agent/            # Apex: Core build agent (language-agnostic)\n├── test-designer/          # Apex: Verification suite design\n├── schematic-generator/    # Apex: Schematics, netlists, HDL\n├── domains/                # Apex: Language-specific build agent extensions\n│   ├── build-agent-dart/\n│   ├── build-agent-embedded/\n│   ├── build-agent-js/\n│   ├── build-agent-nestjs/\n│   └── build-agent-python/\n├── red-team-verifier/      # Right Side: Verification and Red Teaming\n├── compliance-auditor/     # Compliance: Audit and governance\n└── documentation-agent/    # Documentation: Standards-based repo docs (ISO 9001, V-Model, ISO 27001)\n```\n\n| Skill | Category | Path | Purpose |\n|---|---|---|---|\n| agile-v-core | Foundation | `agile-v-core/` |\nThe baseline \"operating system\" for all agents. Includes context engineering, orchestration pipeline, state persistence, and model tier guidance. |\n| requirement-architect | Left Side | `requirement-architect/` |\nConverts intent into atomic, traceable requirements. |\n| logic-gatekeeper | Left Side | `logic-gatekeeper/` |\nValidates requirements for ambiguity and physical/hardware constraints. |\n| build-agent | Apex | `build-agent/` |\nGenerates code, firmware, HDL from approved requirements (language-agnostic). Includes context engineering, pre-execution validation, and post-verification feedback loop. |\n| test-designer | Apex | `test-designer/` |\nDesigns verification suite from requirements only—runs parallel to Build Agent. |\n| schematic-generator | Apex | `schematic-generator/` |\nGenerates schematics, netlists, HDL for hardware/PCB projects. |\n| build-agent-python | Apex | `domains/build-agent-python/` |\nComprehensive Python build agent for backends (FastAPI/Flask/Django), data pipelines, ML, and scripts. Includes architecture patterns, testing strategy, security guidance, and SCOPE-V integration. |\n| build-agent-js | Apex | `domains/build-agent-js/` |\nComprehensive JavaScript/TypeScript build agent for React/Next.js frontends and Node.js backends. Includes state management, security patterns, testing strategy, and build tools. |\n| build-agent-dart | Apex | `domains/build-agent-dart/` |\nComprehensive Dart/Flutter build agent for mobile apps. Includes BLoC/Provider state management, platform channels, widget patterns, and testing strategy. |\n| build-agent-embedded | Apex | `domains/build-agent-embedded/` |\nComprehensive embedded C/C++ build agent for safety-critical systems. Includes MISRA-C, RTOS patterns, hardware abstraction, security, and certification support (ISO 26262, IEC 61508). |\n| build-agent-nestjs | Apex | `domains/build-agent-nestjs/` |\nComprehensive NestJS build agent for enterprise backends. Includes dependency injection, TypeORM/Prisma, GraphQL, microservices, and testing patterns. |\n| red-team-verifier | Right Side | `red-team-verifier/` |\nChallenges build artifacts; produces Validation Summary for Human Gate 2. Includes stub/anti-pattern detection and post-verification feedback protocol. |\n| compliance-auditor | Compliance | `compliance-auditor/` |\nAutomates decision logging, traceability matrix (ATM), and VSR for ISO/GxP. |\n| documentation-agent | Compliance | `documentation-agent/` |\nGenerates standards-based repo documentation (ISO 9001, V-Model, ISO 27001, optional GAMP 5) into `docs/` with hub README, cross-reference matrix, Mermaid diagrams, and compliance posture documentation. |\n\nThe repository includes a full compliance posture assessment under `[docs/compliance/](docs/compliance/)`\n\n. This documentation was generated from a clause-by-clause audit of the v1.3 skills against ISO 9001:2015, ISO 13485:2016, AS9100D, ISO 27001:2022, and GxP/GAMP 5.\n\n| Document | Purpose |\n|---|---|\n|\n\n[ISO 9001 Matrix](/Agile-V/agile_v_skills/blob/main/docs/compliance/02_ISO_9001_MATRIX.md)[ISO 13485 Matrix](/Agile-V/agile_v_skills/blob/main/docs/compliance/03_ISO_13485_MATRIX.md)[AS9100D Matrix](/Agile-V/agile_v_skills/blob/main/docs/compliance/04_AS9100D_MATRIX.md)[ISO 27001 Matrix](/Agile-V/agile_v_skills/blob/main/docs/compliance/05_ISO_27001_MATRIX.md)[GxP / GAMP 5 Matrix](/Agile-V/agile_v_skills/blob/main/docs/compliance/06_GXP_GAMP5_MATRIX.md)[Gap Roadmap](/Agile-V/agile_v_skills/blob/main/docs/compliance/07_GAP_ROADMAP.md)Note\n\nThe skills claim `\"ISO 9001 / ISO 27001 Aligned (Design Phase); GxP-Aware\"`\n\n. This is an honest scope -- the skills cover design and development controls, not production, manufacturing, or full organizational QMS. The compliance documentation tells you exactly what you get and what you still need to do for your regulatory context.\n\n```\nsequenceDiagram\n    participant Human\n    participant RA as Requirement Architect\n    participant LG as Logic Gatekeeper\n    participant BA as Build Agent\n    participant TD as Test Designer\n    participant RTV as Red Team Verifier\n    participant CA as Compliance Auditor\n    participant DA as Documentation Agent\n\n    Human->>RA: Product Intent\n    RA->>RA: REQ-XXXX, Blueprint\n    RA->>Human: Human Gate 1: Approve Blueprint\n    Human->>LG: Approved Blueprint\n    LG->>LG: Ambiguity and Constraint Check\n    opt Unclear constraints or ambiguity\n        LG->>Human: Halt: Clarify ambiguity or constraints\n        Human->>LG: Clarification\n    end\n    LG->>BA: Approved Requirements\n    LG->>TD: Same Requirements (parallel)\n\n    par Apex\n        BA->>BA: Generate Artifacts and Build Manifest\n        opt Ambiguous requirement\n            BA->>Human: Halt: Clarify requirement\n            Human->>BA: Clarification\n        end\n        TD->>TD: Generate TC-XXXX from REQ only\n    end\n\n    BA->>RTV: Artifacts and Manifest\n    TD->>RTV: Test Cases\n    RTV->>RTV: Execute Tests (independent verification)\n    RTV->>Human: Human Gate 2: Validation Summary\n    CA->>CA: Decision Log, ATM, VSR (throughout)\n    opt On request\n        Human->>DA: Generate or refresh docs\n        DA->>DA: docs/ suite (hub, standards, cross-ref)\n    end\n```\n\nThe Requirement Architect exports the approved Blueprint (after Human Gate 1) to a **requirements file** (default: `REQUIREMENTS.md`\n\nin the project root). The Logic Gatekeeper then **reads** that file, validates it (ambiguity, constraints, conflicts), and **writes back** any user-approved adjustments to the same file. All downstream agents (Build Agent, Test Designer, Red Team Verifier, Schematic Generator, Compliance Auditor) **read requirements from this file**, not from in-chat handoff. Using a single persisted file as the requirements source reduces context-window pressure, avoids carrying the full Blueprint in conversation, and lets parallel or sequential agent runs (e.g. build per feature) reference the same canonical artifact.\n\nThe Documentation Agent writes all output into the project's `**docs/`\n\n** directory (created if missing). The hub `**docs/README.md**`\n\nprovides the document map, quick navigation and per-standard tables, cross-reference matrix (concerns × standards), repository structure reference, and applicable standards table. One subdirectory per selected standard, e.g. `**iso9001/**`\n\n, `**iso27001/**`\n\n, `**v-model/**`\n\nby default; (optionally `**gamp5/**`\n\nor other standards when the user requests it) contains numbered markdown documents for that standard. Every generated document (except the hub) includes a header (Document ID, Version, Date, Classification, Status), navigation (Back to Documentation Hub, Previous/Next when applicable), and a footer with a Document History table; any diagrams are Mermaid only, embedded in markdown. The default standards are ISO 9001, V-Model (lifecycle), and ISO 27001; additional standards (e.g. GAMP 5) are included only when the user specifies them.\n\nVersion 1.2 introduces **context engineering**, **orchestration pipeline**, **state persistence**, and **post-verification feedback** patterns adapted from [Get Shit Done (GSD)](https://github.com/gsd-build/get-shit-done) by Lex Christopherson ([MIT License](https://github.com/gsd-build/get-shit-done/blob/main/LICENSE)). These additions address how agents manage context windows, coordinate handoffs, persist project state across sessions, and iterate after verification failures.\n\n**Key additions:**\n\n**Context Engineering**(`agile-v-core`\n\n,`build-agent`\n\n, all domain agents): Rules for managing context window quality -- thin orchestrator pattern, fresh context per task, task sizing to 50% of context, passing file paths instead of contents.**Orchestration Pipeline**(`agile-v-core`\n\n): Defines pipeline stages, handoff rules, wave-based parallel execution with dependency analysis, and checkpoint types (auto, human-verify, human-decision, human-action).**State Persistence**(`agile-v-core`\n\n): Standard`.agile-v/`\n\nproject directory structure for persisting requirements, build manifests, decision logs, traceability matrices, and session state across sessions.**Pre-Execution Validation**(`build-agent`\n\n): 5-dimension check before synthesis -- requirement coverage, artifact completeness, dependency order, scope sanity, and interface contracts.**Post-Verification Feedback Loop**(`build-agent`\n\n,`red-team-verifier`\n\n): Auto-fix rules, severity classification (CRITICAL/MAJOR/MINOR), 3-attempt limit per failure, and re-verification protocol with append-only records.**Stub and Anti-Pattern Detection**(`red-team-verifier`\n\n): 11-item detection checklist for placeholder returns, TODO markers, empty handlers, hardcoded secrets, and more.**Model Tier Guidance**(`agile-v-core`\n\n): Recommended model capability tiers per agent role (High for architecture decisions, Medium for code generation, Low for structured logging).\n\nVersion 1.3 introduces the **multi-cycle V-loop** -- the ability to run second and subsequent iterations while preserving full traceability, versioned documents, and audit evidence from prior cycles.\n\n**Key additions:**\n\n**Iteration Lifecycle**(`agile-v-core`\n\n): Defines Cycle IDs (`C1`\n\n,`C2`\n\n, ...), cycle triggers, re-entry points, document versioning scheme, and cycle archival to`.agile-v/cycles/CN/`\n\n. Requirements carry per-REQ status tags (`approved`\n\n,`modified`\n\n,`new`\n\n,`deprecated`\n\n,`superseded`\n\n) with cycle references.**Change Request Protocol**(`agile-v-core`\n\n,`requirement-architect`\n\n):`CR-XXXX`\n\nrecords in`.agile-v/CHANGE_LOG.md`\n\nthat formally track every requirement modification between cycles with rationale, impact analysis, and Human Gate approval.**Multi-Cycle Re-Validation**(`logic-gatekeeper`\n\n): Scoped re-validation -- only`new`\n\nand`modified`\n\nrequirements go through full validation; unchanged requirements are skipped unless constraints shifted.**Artifact Versioning**(`build-agent`\n\n):`ART-XXXX.N`\n\nrevision scheme -- unchanged artifacts carry forward without rebuild; modified artifacts get a revision bump with CR reference.**Regression and Delta Testing**(`test-designer`\n\n): Test cases classified as`delta`\n\n(new/modified REQs) or`regression`\n\n(unchanged REQs). Regression baseline carried forward from prior cycle. Retired tests preserved for traceability.**Cycle-Aware Verification**(`red-team-verifier`\n\n): Delta and regression results reported separately. Unexpected regression failures (no related CR) are automatically**CRITICAL**.** Cycle-Aware ATM**(`compliance-auditor`\n\n): Traceability matrix partitioned by cycle. CR end-to-end chain validation. Cycle boundary audit checklist. VSR extended with Cycle History table.\n\nVersion 1.4 adds **Phase 1-2** adoption from the competitive analysis: machine-readable **trace** (`TRACE_LOG.md`\n\n), **eval flywheel** (`EVAL_RESULTS.md`\n\n+ Human Gate 2 **EvalGate** block in `VALIDATION_SUMMARY.md`\n\n), **policy-as-code** (`POLICY.yaml`\n\n+ templates), **failure taxonomy** (`FT-*`\n\ncodes on every `VER-*`\n\nrecord), and **durable Human Gate checkpoints** (`CHECKPOINTS.md`\n\nwith `resume_token`\n\nlinked to `APPROVALS.md`\n\n). Normative schema: [ docs/agile-v-runtime/01_SCHEMAS.md](/Agile-V/agile_v_skills/blob/main/docs/agile-v-runtime/01_SCHEMAS.md); copy templates from\n\n[.](/Agile-V/agile_v_skills/blob/main/templates/agile-v)\n\n`templates/agile-v/`\n\nVersion 1.6 consolidates runtime governance adoption by shipping the repository-level runtime schema spec + templates and aligning core routing/docs for Eval Gate evidence and durable HITL workflow. See [v1.6 release notes](/Agile-V/agile_v_skills/blob/main/V1.6_RELEASE_NOTES.md).\n\nVersion 1.3 also includes compliance hardening based on a clause-by-clause audit against ISO 9001:2015, ISO 13485:2016, AS9100D, ISO 27001:2022, and GxP/GAMP 5. The compliance metadata has been updated from `\"ISO/GxP-Ready\"`\n\nto `\"ISO 9001 / ISO 27001 Aligned (Design Phase); GxP-Aware\"`\n\nto accurately reflect the scope.\n\n**Key additions:**\n\n**Risk Management**(`agile-v-core`\n\n):`RISK_REGISTER.md`\n\nwith severity matrix, risk categories (technical, process, compliance, security), and assessment rules per pipeline stage. Addresses ISO 9001 6.1, AS9100D 8.1.1.**CAPA Protocol**(`agile-v-core`\n\n):`CAPA_LOG.md`\n\nwith root cause analysis (5-Whys), corrective action, preventive action, and effectiveness verification. Addresses ISO 13485 8.5, ISO 9001 10.1/10.2.**Human Gate Approval Records**(`agile-v-core`\n\n):`APPROVALS.md`\n\nwith approver identity, role/authority, signature method, and evidence reference. Minimum requirements by regulatory context (non-regulated through ISO 13485). Addresses 21 CFR Part 11, Annex 11.**AI Agent Security Controls**(`agile-v-core`\n\n): LLM provider documentation in`config.json`\n\n(data residency, retention, training usage, confidentiality certification), data classification rules, agent access controls, and file integrity verification. Addresses ISO 27001 A.5.23, A.8.3.**Periodic Review and Revalidation**(`agile-v-core`\n\n):`REVALIDATION_LOG.md`\n\nwith defined triggers (model change, runtime change, skill change, accumulated CRs, 12-month interval). Model version tracking in`config.json`\n\n. Addresses GxP/GAMP 5 periodic review.**Quality Metrics and KPIs**(`compliance-auditor`\n\n): 7 defined metrics (first-pass verification rate, defect density, requirement coverage, regression pass rate, CR cycle time, open CAPA count, traceability completeness) with trend analysis. Addresses ISO 9001 9.1, AS9100D 9.1.1.**Secure Coding**(`build-agent`\n\n): 7 minimum secure coding rules (input validation, error handling, no hardcoded secrets, parameterized queries, bounded operations, least privilege, dependency awareness). Addresses ISO 27001 A.8.28.**Nonconformity Disposition**(`red-team-verifier`\n\n): Formal disposition categories (rework, accept-as-is, reject, defer) with CAPA trigger criteria. Addresses ISO 9001 8.7, ISO 13485 8.3.\n\nAll 8 core skill files have been rewritten for minimal context window consumption. Total reduction: **1,670 → 670 lines (60%)**, with zero information loss.\n\n| Skill | Before | After | Reduction |\n|---|---|---|---|\n| agile-v-core | 610 lines / 33 KB | 227 lines / 12 KB | 63% |\n| build-agent | 151 lines / 9.6 KB | 74 lines / 3.8 KB | 51% |\n| red-team-verifier | 212 lines / 10.5 KB | 89 lines / 4.2 KB | 58% |\n| compliance-auditor | 186 lines / 8.4 KB | 77 lines / 3.3 KB | 59% |\n| requirement-architect | 119 lines | 50 lines | 58% |\n| logic-gatekeeper | 71 lines | 38 lines | 46% |\n| test-designer | 124 lines | 53 lines | 57% |\n| documentation-agent | 197 lines | 62 lines | 69% |\n\n**Techniques used:**\n\n`**sections_index`\n\nin YAML frontmatter** -- agents jump to the section they need without scanning the full document.**Directive tables** replace prose paragraphs -- 6 core directives fit in one table instead of 6 subsections.**Inline notation**(`;`\n\nand`·`\n\nseparators, numbered items on single lines) replaces verbose multi-line bullets.**Format templates show structure only**-- one example is sufficient; agents know how to repeat a pattern.** Cross-references**replace duplication -- \"see agile-v-core\" instead of re-explaining shared concepts.\n\n**Impact on agent execution:**\n\n`agile-v-core`\n\nconsumes ~~12 KB (~~3% of a 200K context window) instead of 33 KB (~8%).- A typical workflow loads core + one role skill: ~16 KB total vs ~43 KB before.\n- The\n`sections_index`\n\nenables immediate section lookup, reducing scanning overhead.\n\nImportant\n\n**Maintain Rigorous Test Independence:**\n\nWhen running the workflow within a **single chat** or environment, **always execute the Test Designer before launching the Build Agent**. This ensures the Test Designer derives its test suite solely from the requirements and not from any artifacts, code, or outputs generated by the Build Agent.\n\nBy preserving this strict order, you safeguard the impartiality of the verification process and prevent accidental cross-contamination, thereby maximizing the integrity and trustworthiness of your independent test coverage.\n\nTip\n\n**Scaling the build phase:** With a large number of features or requirements, consider running the build agent **per feature or per small subset** (sequentially) to improve focus and quality. Running **multiple build-agent instances in parallel** can speed things up but may introduce race conditions (e.g. concurrent edits to the same files); use with care and plan your merge or review strategy accordingly. See the **Wave-Based Parallel Execution** section in `agile-v-core`\n\nfor dependency-aware parallelism guidance.\n\nBelow are practical ways to use these skills in common editors and agents.\n\n**Cursor**\n\nSkills are discovered from`.cursor/skills/`\n\n(project) or`~/.cursor/skills/`\n\n(global). Each skill is a folder containing a`SKILL.md`\n\nfile with YAML frontmatter. The agent auto-applies relevant skills; you can also invoke a skill manually by typing`/`\n\nin Agent chat and searching for the skill name. Clone this repo and copy the skill folders you need (e.g.`agile-v-core/`\n\n,`requirement-architect/`\n\n,`domains/build-agent-python/`\n\n) into`.cursor/skills/`\n\n. For more information on how to use Skills in Cursor please refer to the[official documentation](https://cursor.com/docs/context/skills).**Claude Code**\n\nSkills are discovered from`.claude/skills/`\n\n(project) or`~/.claude/skills/`\n\n(global). Each skill is a folder containing a`SKILL.md`\n\nfile with YAML frontmatter. The agent auto-applies relevant skills; you can also invoke a skill manually by typing`/`\n\nin Agent chat and searching for the skill name. Clone this repo and copy the skill folders you need (e.g.`agile-v-core/`\n\n,`requirement-architect/`\n\n,`domains/build-agent-python/`\n\n) into`.claude/skills/`\n\n. For more information on how to use Skills in Cursor please refer to the[official documentation](https://code.claude.com/docs/en/skills).**VS Code**\n\nVS Code supports two types of skills. Project skills, stored in your repository like`.github/skills/`\n\n,`.claude/skills`\n\n,`.agents/skills/`\n\nor personal skills stored globally like`~/.copilot/skills/`\n\n,`~/.claude/skills`\n\n,`~/.agents/skills/`\n\n. The agent auto-applies relevant skills; you can also invoke a skill manually by typing`/`\n\nin Agent chat and searching for the skill name. Clone this repo and copy the skill folders you need (e.g.`agile-v-core/`\n\n,`requirement-architect/`\n\n,`domains/build-agent-python/`\n\n) into one of the directories mentioned above. For more information on how to use Skills in VS Code please refer to the[official documentation](https://code.visualstudio.com/docs/copilot/customization/agent-skills).**GitHub Copilot**\n\nGithub Copilot supports two types of skills. Project skills, stored in your repository like`.github/skills/`\n\n,`.claude/skills`\n\nor personal skills stored globally like`~/.copilot/skills/`\n\n,`~/.claude/skills`\n\n. The agent auto-applies relevant skills; you can also invoke a skill manually by typing`/`\n\nin Agent chat and searching for the skill name. Clone this repo and copy the skill folders you need (e.g.`agile-v-core/`\n\n,`requirement-architect/`\n\n,`domains/build-agent-python/`\n\n) into one of the directories mentioned above. For more information on how to use Skills with Github Copilot please refer to the[official documentation](https://docs.github.com/en/copilot/concepts/agents/about-agent-skills).**Other tools (Claude Agent SDK, Windsurf, Continue, Cody, Zed, etc.)**\n\nFor other tools please refer to the official documentation of your desired tool.\n\nTo learn more about skills and how to use skills in general, please follow the [instructions and documentation](https://agentskills.io/integrate-skills) of Agent Skills.\n\nAgile V is actively protecting your development process if you observe these behaviors:\n\n- ✅ Every code file includes\n`// REQ-XXXX`\n\nor`# Implements: REQ-XXXX`\n\ncomments linking to requirements - ✅\n`.agile-v/REQUIREMENTS.md`\n\nexists with formal requirement specifications - ✅\n`.agile-v/BUILD_MANIFEST.md`\n\nmaps every artifact (ART-XXXX) to its parent requirement - ✅ Each requirement includes acceptance criteria and rationale\n\n**Example:**\n\n```\n# app/auth.py\n# ART-0001: User authentication handler\n# Implements: REQ-0001 (username/password authentication)\n# Compliance: ISO 27001 A.9.4.1\n```\n\n- ✅ Instead of assuming, agents ask clarifying questions before implementing\n- ✅\n`⚠️ HALT CONDITION`\n\nmessages appear when requirements are unclear or missing - ✅ Agents present multiple interpretations when faced with ambiguous requests\n- ✅ No \"silent assumptions\" about hardware, scope, or user intent\n\n**Example:**\n\n```\nUser: \"Make the app faster\"\n\nAgent: ⚠️ HALT CONDITION: Ambiguous requirement\n\n\"Faster\" could mean:\n1. Faster response time (backend optimization)\n2. Faster perceived speed (UI/UX improvements)\n3. Faster time-to-first-byte (infrastructure)\n\nWhich aspect matters most for your use case?\n```\n\n- ✅ Build Agent implements features\n- ✅ Red Team Verifier tests independently (separate agent, fresh context)\n- ✅ Red Team finds issues Build Agent didn't self-detect\n- ✅ Evidence Summaries show both perspectives before Human Gates\n\n**Example:**\n\n```\nBuild Agent: Implementation complete ✓\nRed Team Verifier: Found 4 security issues Build Agent missed\n  - SECURITY-001: No maximum password length (DoS risk)\n  - SECURITY-002: Unicode character bypass\n```\n\n- ✅ Agents ask about target platform before optimizing (embedded vs cloud vs workstation)\n- ✅ Implementations stay within specified resource limits (RAM, CPU, GPU)\n- ✅ No assumptions about unlimited compute resources\n- ✅ Physical constraints documented in requirements\n\n**Example:**\n\n```\nAgent: ⚠️ HALT CONDITION: Hardware constraints unknown\n\nBefore optimizing image processing:\n1. Target platform? (RPi4, workstation, cloud?)\n2. Available RAM?\n3. GPU availability?\n```\n\n- ✅ Before deployments, comprehensive Evidence Summaries appear\n- ✅ Approvals logged with timestamp and approver ID\n- ✅ No autonomous production deployments\n- ✅ Clear decision points documented\n\n**Example:**\n\n```\n=== EVIDENCE SUMMARY ===\nScope: Deploy API v2.1.0 to production\nTraceability: REQ-0101 to REQ-0115 (15 requirements) ✓\nTest Results: 47/47 PASS\nRisk Assessment: RISK-003 mitigated ✓\n\n🛑 AWAITING HUMAN APPROVAL\n```\n\n- ✅\n`.agile-v/DECISION_LOG.md`\n\nis append-only audit trail - ✅ Every significant choice includes timestamp, agent ID, rationale, and linked requirement\n- ✅ Alternative approaches considered and documented\n- ✅ Compliance-ready audit evidence\n\n**Example:**\n\n```\nTIMESTAMP: 2026-05-26T10:30:00Z\nAGENT_ID: build-agent-python\nDECISION: Use sequential processing instead of parallel\nRATIONALE: Target hardware (RPi4) has only 4GB RAM\nLINKED_REQ: REQ-0010\nALTERNATIVE_CONSIDERED: ProcessPoolExecutor with 2 workers\nALTERNATIVE_REJECTED: Still risks OOM with high-res images\n```\n\n- ✅ Change Requests (CR-XXXX) tracked in\n`.agile-v/CHANGE_LOG.md`\n\n- ✅ Prior cycle artifacts archived to\n`.agile-v/cycles/C1/`\n\n,`C2/`\n\n, etc. - ✅ Requirements carry status tags (\n`new`\n\n,`modified`\n\n,`deprecated`\n\n,`superseded`\n\n) - ✅ Regression testing distinguishes delta tests from baseline tests\n\n- ✅ Requirements map to compliance standards (ISO 9001, ISO 27001, GxP)\n- ✅ Traceability matrix (ATM) auto-generated in\n`.agile-v/ATM.md`\n\n- ✅ Risk register and CAPA log maintained\n- ✅ Verification Summary Report (VSR) ready for audits\n\n**If you're NOT seeing these behaviors**, the Agile V skills may not be properly loaded or configured. See [EXAMPLES.md](/Agile-V/agile_v_skills/blob/main/EXAMPLES.md) for concrete before/after scenarios, or refer to [CLAUDE.md](/Agile-V/agile_v_skills/blob/main/CLAUDE.md) and [CURSOR.md](/Agile-V/agile_v_skills/blob/main/CURSOR.md) for platform-specific setup guides.\n\nAgile V™ is built to function as the quality layer between your team’s expertise and any AI agent they use. Whether teams rely on proprietary LLMs, local models, or different IDEs, the **engineering standard remains consistent** across the organization.\nThanks to Agent Skills every agent behaves according to the same engineering principles, no matter where or how it runs.\n\nOrganizations can extend the public Agile V™ skills (e.g., `agile-v-core`\n\n) with private **Company Skills** that embed institutional knowledge directly into agent behavior.\n\n**Internal Compliance:** Wrap Agile V™ skills with company-specific safety protocols, regulatory checklists, or GxP requirements so every agent interaction is compliant by default.**Legacy Wisdom:** Capture “lessons learned” from past projects in a**Gatekeeper Skill** that prevents agents from repeating known failure modes or architectural mistakes.**Tool Agnostic Logic:** Because Agile V™ focuses on*Logic Gates*and*Traceability*, it works whether your team uses GitHub Copilot, Cursor, custom LangChain flows, or manual prompting.\n\nYour standards live in the skills, not in the tool.\n\nAgile V™ establishes a minimum quality floor across all teams and agents.\n\n**Uniform Audits:** Every developer, regardless of experience level, uses agents that follow the same**Red Team Protocol** and quality checks.**Decoupled Intelligence:** When switching from one AI model to another, your**Agile V™ Skills** preserve engineering constraints, review gates, and your Definition of Done.**Institutional Memory:** With Principle #9 (Decision Logging), the reasoning behind engineering choices is stored in the repository, not in individual developers’ heads, ensuring long-term maintainability.\n\nTip\n\nTeams can maintain a private `/internal-skills`\n\ndirectory that inherits from the root-level skills (e.g., `agile-v-core/`\n\n). This enables a **“Global Standard, Local Context”** workflow; shared principles with company-specific adaptations.\n\nAgile V can consume an [Understand Anything](https://github.com/Lum1104/Understand-Anything)\nknowledge graph to add codebase-understanding, impact analysis, graph traceability, and\nregression-test selection to the Agile V lifecycle.\n\nThis enables:\n\n- Requirement → component → test traceability\n- Change-impact analysis before writing code\n- Regression-test selection from the dependency graph\n- Audit-ready evidence bundles with system context\n- Reviewer-friendly architecture maps\n\n| Skill | Path | Purpose |\n|---|---|---|\n`system-understanding-agent` |\n`skills/system-understanding-agent/` |\nGate 0: consume graph, produce system overview |\n`impact-analysis-agent` |\n`skills/impact-analysis-agent/` |\nMap change request to affected components |\n`graph-traceability-agent` |\n`skills/graph-traceability-agent/` |\nLink REQs to graph nodes, files, and tests |\n`regression-selection-agent` |\n`skills/regression-selection-agent/` |\nSelect and prioritize regression tests |\n`diff-evidence-agent` |\n`skills/diff-evidence-agent/` |\nCompare predicted vs actual impact |\n\nSee `integrations/understand-anything/`\n\nfor:\n\n- Adapter contract (graph format → Agile V schema)\n- Evidence mapping (which artifacts go where in the bundle)\n- Graph assumptions and tolerant loading strategy\n- Security and privacy guidance for evidence exports\n- End-to-end examples\n\nUnderstand the system. Change it safely. Prove what changed.\n\nThe `agentic_agile_v`\n\nrepository provides the runtime adapter, Python modules, JSON schemas,\nand unit tests. CLI commands are planned for Phase 3 and are not yet available.\nSee `docs/understand-anything-integration.md`\n\nin that repository.\n\n**Repository:** The repo uses[semantic versioning](https://semver.org/)driven by[Conventional Commits](https://www.conventionalcommits.org/). On each push to`main`\n\n, a GitHub Action reads the commit message and bumps the version accordingly:`feat:`\n\n→ minor,`fix:`\n\n(and`chore:`\n\n,`docs:`\n\n, etc.) → patch,`BREAKING CHANGE`\n\nor`type!:`\n\n→ major. It then creates a new git tag (e.g.`v1.5.1`\n\n) and updates the root`[package.json](package.json)`\n\n. The version field and tag are maintained by the workflow; do not edit`package.json`\n\nversion by hand for releases. The same file holds repo metadata (name, description, author, repository, license).**Skills:** Each skill is versioned independently via`metadata.version`\n\nin its`SKILL.md`\n\nfrontmatter ([agentskills.io](https://agentskills.io/specification)style). Skills are not version-locked to each other; bump a skill’s version only when that skill’s content or contract changes.\n\nWe welcome contributions! To add a new skill to the Agile V™ ecosystem, it must adhere to the following rules:\n\n**Strict Traceability:** The skill must include procedures for logging the \"Why\" behind every output.**Verification Step:** If the skill generates an artifact, it must include a sub-process for checking that artifact against its parent requirement.**No Hallucination:** The skill must be instructed to \"Halt and Ask\" when requirements are ambiguous.**Format:** Must include a SKILL.md with valid YAML frontmatter as per the[agentskills.io spec](https://agentskills.io/specification).**License:** The skill must be licensed under**CC-BY-SA-4.0**(Creative Commons Attribution-ShareAlike 4.0). Include`license: CC-BY-SA-4.0`\n\nin the frontmatter.**Metadata:** The skill must include`metadata.author`\n\n(e.g.,`agile-v.org`\n\n) and`metadata.version`\n\n(e.g.,`\"1.0\"`\n\n). Each skill has its own version; maintainers bump it when that skill changes.\n\nNote\n\n**Contribution guidelines in progress:** We are currently developing comprehensive contribution guidelines for the community. The rules above are the current minimum requirements. A full spec, including review process, quality checklist, and community standards, will be published soon. Watch this space or check [agile-v.org](https://agile-v.org) for updates.\n\nThe Agile V™ Agent Skills Library is published under the ** Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)** license.", "url": "https://wpnews.pro/news/agile-v-turning-ai-agents-into-verifiable-engineering-systems", "canonical_source": "https://github.com/Agile-V/agile_v_skills", "published_at": "2026-05-26 22:09:32+00:00", "updated_at": "2026-05-26 22:37:28.920729+00:00", "lang": "en", "topics": ["ai-agents", "ai-safety", "ai-tools", "ai-products", "mlops"], "entities": ["Claude Code", "Cursor", "VS Code", "GitHub Copilot", "ISO 9001", "ISO 27001", "GxP", "Agile V"], "alternates": {"html": "https://wpnews.pro/news/agile-v-turning-ai-agents-into-verifiable-engineering-systems", "markdown": "https://wpnews.pro/news/agile-v-turning-ai-agents-into-verifiable-engineering-systems.md", "text": "https://wpnews.pro/news/agile-v-turning-ai-agents-into-verifiable-engineering-systems.txt", "jsonld": "https://wpnews.pro/news/agile-v-turning-ai-agents-into-verifiable-engineering-systems.jsonld"}}