ai-workspace-generator

Produce a prioritized, read-only audit of the workspace's health and coherence (code, docs, integrity, standards) as a dated report. Use periodically or after big changes to surface what to improve. Read-only — it reports and recommends, never fixes.

Configure or re-configure this AI workspace: analyze an existing repo (or set up a new one) and propose a workspace.config.yaml + skill set. Trigger: when the user wants to set up, configure, or re-detect the workspace.

Assess feasibility and security of version bumps/migrations before touching anything. Trigger: when asked to update dependencies, migrate, or resolve version conflicts.

Keep the living docs (project status) current so the AI always has fresh project context. Trigger: after finishing a task or when project state changed.

Implement the tasks in order, keeping the code aligned with the spec and design, checking each off as it lands. Use to execute an agreed plan — if reality diverges from the spec, stop and update the spec first.

Fold a verified change's delta into the stable specs and move its folder to the archive. Use only after verify passes: ADDED requirements are appended, MODIFIED replace, REMOVED delete; then the change is archived with its full history.

Surface and resolve ambiguity before the spec is written: ask targeted questions about underspecified behaviour, edge cases and decisions, and record the answers. Use between proposal and spec whenever the proposal leaves choices open.

Decide HOW the spec is met: the technical approach, the key architecture decisions and their trade-offs, with Mermaid diagrams where they clarify. Use after the spec is stable, before breaking work into tasks.

Investigate a feature or bug before committing to an approach: frame the problem, survey the relevant code, and lay out options with trade-offs. Use at the very start of a non-trivial change, when the problem or solution space is still unclear.

Turn an explored idea into a reviewable proposal: state the why, the scope (in and out), the approach, and the risks. Use once exploration converges and before writing the spec — it is the decision artifact a reviewer signs off.

Specify WHAT must be true as a delta against the current specs — testable requirements and acceptance scenarios in the OpenSpec delta format. Use after clarify; the spec, not the code, is the source of truth for behaviour. Avoid HOW (that is design).

Break the spec and design into an ordered, checkable task list — small, verifiable steps that map back to requirements. Use once spec and design are agreed, to drive (and track) implementation.

Validate the implementation against the spec: walk every requirement and acceptance scenario, run the checks, and report any gaps. Use after apply, before archiving — it is the evidence the change is actually done.

Create commits per policy (no co-author, with approval, conventional). Trigger: when committing changes.

Set up VS Code (recommended extensions and profiles) to work well with this workspace. Trigger: when the user asks about extensions, VS Code profiles, or preparing the editor.

Teaches how to use this AI workspace (SDD, skills, MCP), for people new to AI. Trigger: when the user asks how to use the workspace, how to start, or what SDD is.

Audit the project layout/architecture against the canonical layouts (LAYOUTS + CONV-STRUCT). Trigger: architecture review.

Audit a REASONS spec/app against a catalogue of security controls (SEC-*). Trigger: security review or before approving a spec for deployment.

Audit the tech stack against the profile's catalogue (TECH-A-* / TECH-B-*). Trigger: stack review.

Audit code style/conventions against a catalogue of engineering conventions (CONV-*). Trigger: style review.

Generate application code from a user-reviewed REASONS spec — Profile A (layered FastAPI/SQLAlchemy) or B (ES modules + SRI CDN). Trigger: materialising a signed-off spec as code.

Propagate a REASONS spec change into existing code — diff old vs active spec, classify each change, apply with per-change confirmation. Trigger: code must follow an edited spec.

Package a finished REASONS project for IT review — verify a READY self-review, write a handoff README (versions, install/run/test, TODOs), optional clean ZIP. Trigger: app ready for IT.

Scaffold the project layout for the spec's app profile (A=Python/FastAPI · B=HTML+JS). Trigger: starting a new app in `sdd.schema: reasons` mode, after the profile is chosen.

Migrate a legacy non-Git SDD workspace (`_vN` filenames + `sdd_docs/`) to the unified Git-based model. Trigger: adopting this generator on a repo built with standalone, pre-Git SDD plugins.

Pick the app profile (A=Python / B=HTML+JS) via a plain-language decision tree and set the spec flags. Trigger: starting a new app in `sdd.schema: reasons` mode, or when the profile is undecided.

Recover a draft REASONS spec from an existing codebase that arrived without one (or whose spec drifted). Trigger: auditing code that lacks a current spec (reviewer/IT side).

Run the full pre-handoff validation gauntlet (lint, types, tests, coverage, security, SDD-trail consistency) and emit a PASS/FAIL report citing rule IDs. Trigger: self-check before handoff.

Guided conversational interview that turns plain-language needs into a valid REASONS spec (8 sections, closed frontmatter). Trigger: creating a new spec in `sdd.schema: reasons` mode.

Review and edit a REASONS spec and drive its status lifecycle (draft → user-reviewed → it-approved → implemented → retired) with sign-off gates. Trigger: revising a spec or signing it off.

REASONS Canvas spec schema (8 sections + closed frontmatter, profiles A/B). Trigger: when authoring, reviewing or validating a spec in `sdd.schema: reasons` mode.

SPDD code→prompt sync — fold non-behavioural code changes back into the REASONS Canvas and report spec↔code drift. Propose-and-review, never auto-apply. Trigger: code was refactored/fixed and the spec must catch up, or to check drift.

Generate the test suite from the spec's §5 Tests blocks — Profile A pytest (70% coverage, TECH-A-013) or Profile B smoke checklist. Trigger: after code generation.

Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.

Odoo 18 development reference for Python models and ORM (search, domain, read_group, compute fields), XML/CSV data and views, OWL/JS client code, QWeb reports, security (ACL, record rules, groups), cron and server actions, migrations and module upgrades, tests, i18n, and performance. Use this skill whenever work involves Odoo 18 or custom addons—even if the user only pastes a traceback, mentions addons/ or __manifest__.py, describes form/list/kanban/XML errors, HTTP controllers, or business rules on models—including building features, fixing bugs, refactoring, or reviewing addon code.

Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.

Review Odoo code for correctness, security, performance, and version-specific standards (Odoo 17, 18, or 19). Use when reviewing Odoo modules, diffs, or pull requests; produce a scored report with weighted criteria.

Trace Odoo code execution flow from entry point to end. Use proactively when planning tasks, reviewing code, or understanding how features work end-to-end. Follows all function calls, method overrides, inheritance chains, and callbacks without missing any execution path.