wu5 dev flow

    1

    A rigorous Python dev workflow enforcing SDD, TDD, and Git gates through an audited state machine.

    Free

    1 useSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    wu5 dev flow

    Example session with this skill installed

    Initialize a new feature called 'user-auth' in this Python repo using the full flow. I need to add JWT verification to the existing login endpoint.

    • Read your context and instructions
    • Compiled the wu5 dev flow

    I have initialized the user-auth change using the full SDD/TDD workflow. The state machine is now at drafting-spec, and I have generated the initial directory structure for this task.

    Initialization Result

    ActionPath/StatusDescription
    Workspace/spec/changes/user-auth/Created directory for feature specifications
    Statedrafting-specCurrent phase in state.json
    Draftedproposal.mdInitial requirement summary for JWT verification
    Drafteddesign.mdPlaceholder for token validation logic and dependency injection
    Scriptwu5_flow.py statusSystem verified: No dirty workspace detected

    Proposed Specification Outline

    I have drafted a proposal focusing on

    1. Dependency Injection: Moving secret keys out of the implementation into a config provider.
    2. Red-Green Plan: Writing a failing test for a 401 response on expired tokens before any implementation.
    3. Review Points: Specifically checking for hardcoded algorithms or salt values.

    Next steps

    1. Review the generated spec/changes/user-auth/proposal.md and provide feedback.
    2. Once satisfied, run python scripts/wu5_flow.py approve spec to lock the requirements.
    3. I will then begin the drafting-plan phase to map specific tests to the JWT logic.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Software projects often fail due to drift between specifications, tests, and implementation. This skill enforces a rigorous, state-machine driven workflow that prevents unverified code from reaching your main branch.

    What it does

    • Enforce SDD/TDD: Requires Software Design Documents and Test-Driven Development cycles for every functional change.
    • Automated Gates: Uses a dedicated Python script to verify project state, approve baselines, and check commit readiness.
    • Zero-Hardcode Policy: Scans and blocks implementation of hardcoded keys, environment-specific paths, or business thresholds.
    • State Persistence: Tracks progress in state.json and status.md to maintain context across different sessions or agents.
    • Atomic Commits: Handles local git staging and commits only after rigorous verification and review cycles.

    How it works

    1. Initialize: Run wu5_flow.py init to scaffold the specification directory and baseline the existing codebase.
    2. Define: Create a new change slug and draft the proposal.md and plan.md for user approval.
    3. Develop: Execute the Red-Green-Refactor loop, ensuring tests fail as expected before writing business logic.
    4. Verify: Run automated checks for types, linting, and test coverage, followed by a two-stage manual review gate.
    5. Ship: Archive the change, update the feature documentation, and prepare the final PR summary.

    Frameworks & tools

    Specifically designed for Python environments using pytest, pyright, and ruff. It integrates directly with Git for workflow enforcement and utilizes custom Python scripts for state management.

    Why this beats prompting it yourself

    Prompting an agent to "follow TDD" often results in shortcuts or forgotten steps over long sessions. This skill uses a hard-coded state machine and external script validation that refuses to proceed if specifications are unapproved or tests are missing.

    Use cases

    • Initializing a new Python project with strict architectural standards.
    • Executing high-stakes refactoring where regression is not an option.
    • Onboarding agents to existing repositories while maintaining a verifiable audit trail.
    • Managing complex feature additions that span multiple work sessions.

    Known limitations

    Does not handle database schema migrations or irreversible data transformations. Requires local Python environment to run the gatekeeper scripts.

    Requires local Python environment to run wu5_flow.py. Excludes database migrations and data transformations. One active change per repository limit.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    Python

    Permissions

    Terminal / Shell
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    The skill enforces a state-machine driven workflow that requires specific documentation and passing tests before any code can be committed, ensuring your specifications and implementation never drift apart.

    This skill is optimized for any LLM-based agent with terminal and filesystem access that supports Python environments, including popular IDE-integrated agents and standalone developer bots.

    You will receive the core state-management script (`wu5_flow.py`), a suite of template structures for SDD/TDD documentation, and the configuration files needed to integrate the automated gates into your local environment.

    Yes, while it is ideal for new projects, you can run the initialization command on an existing repository to baseline your current code and enforce the workflow for all subsequent feature additions.

    The skill is designed for Python development and requires `pytest`, `pyright`, and `ruff` to be installed in your environment for the automated verification gates to function correctly.

    New in Agents & Orchestration