More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Agent Engineering Workflow Pack

    1

    A 13-skill engineering suite to bootstrap codebase context, build features, and maintain documentation for AI agents.

    Free

    3 usesSecurity scanned
    Agent Engineering Workflow Pack

    Agent Engineering Workflow Pack

    Example session with this skill installed

    Before changing this repository, index it completely. Identify the project structure, all Agent Skills, their supporting files, how the skills hand work to one another, the tools they need, and any missing runtime or test infrastructure. Produce a concise CODEBASE_INDEX.md. Do not modify the source files.

    • Read your context and instructions
    • Compiled the agent engineering workflow

    CODEBASE_INDEX.md

    1. Project identity

    FieldFinding
    ProjectAgent Engineering Workflow Pack
    Sourceafuhflynn/agent-skills
    Project typeMulti-skill Agent Skills collection
    Main formatsMarkdown and YAML
    Skills13 individual SKILL.md entry points
    Package contents93 files: 81 Markdown, 11 YAML, and 1 license file
    Build systemNone included or required for the skill instructions
    Runtime dependenciesNo application packages or package manager dependencies bundled
    LicenseMIT, included as LICENSE

    This is a reusable workflow library, not a runnable web application or service. The primary deliverables are skill instructions and the reference files each skill loads when needed.

    2. Top-level structure

    LICENSE
    README.md
    docs/
      conventions.md
      workflow-guide.md
    skills/
      engineering/
        codebase-audit/
        codebase-index/
        context-forge/
        fault-fix/
        feature-build/
        peer-review/
        rules-generator/
        scope-plan/
        solution-architect/
        state-sync/
        test-engineer/
        verify-release/
      productivity/
        tech-writer/
    

    docs/workflow-guide.md explains the handoffs and rigor levels. docs/conventions.md provides shared reporting defaults. Each skill directory contains its own SKILL.md and, where needed, modes, templates, prompts, or reference guides.

    3. Skill entry points

    SkillResponsibilityMain handoff
    scope-planTurns an idea into an ordered, living feature scopesolution-architect
    codebase-indexBuilds a thorough repository indexRead-only onboarding and discovery
    codebase-auditCreates or gap-fills portable AGENTS.md contextcontext-forge or feature work
    context-forgeWrites enforceable agent working rules from evidenceFuture implementation work
    rules-generatorProduces a standalone RULES.mdLegacy or explicitly requested rules format
    solution-architectResolves load-bearing decisions and writes specsfeature-build
    feature-buildImplements a feature from its spec and project contextverify-release
    fault-fixReproduces and fixes a defect at its root causetest-engineer
    verify-releaseExercises the running application against expected behaviorpeer-review or completion
    test-engineerWrites tests for changed codestate-sync after the feature closes
    peer-reviewReviews a change set with fresh eyesfault-fix for findings, then sync
    tech-writerWrites PR and release-facing documentation from changesstate-sync
    state-syncReconciles durable context, scope, and spec statusNext engineering task

    4. Workflow relationships

    For a new project, the documented path is scope-plan → solution-architect → scaffold → codebase-audit → feature workflow.

    For an existing project, the documented path is codebase-audit → context-forge when rules are needed → scope-plan → feature workflow.

    For a feature, the typical path is solution-architect → feature-build → verify-release → test-engineer → peer-review → tech-writer → state-sync. The exact tail is risk-dependent. fault-fix can be used whenever a defect appears. The pack explicitly distinguishes the legacy standalone rules-generator from context-forge, which writes rules into the canonical AGENTS.md file.

    5. Tools and dependencies

    The skills expect an AI agent with file read, search, and write capabilities. Terminal and Git access are used by several workflows. Browser or web research, HTTP testing, and sub-agents improve some tasks but are optional where the skill documents an inline or manual fallback.

    No third-party runtime package, account integration, API key, or MCP server is a mandatory dependency of the pack. Project-specific build, test, database, or deployment tools depend on the repository being worked on.

    6. Tests and infrastructure

    The pack does not include a runnable application, application test suite, database, deployment configuration, or CI pipeline. The skill files define procedures for agents to inspect and test the buyer's own project. The package archive and all 13 skill frontmatter records were checked for structural validity before this index was prepared. Agensi's own security scan and human review remain pending until submission.

    7. Unknowns and recommendations

    • Exact support for optional fields such as allowed-tools, interactive question pickers, browser tools, and sub-agents varies between coding agents.
    • Runtime verification and test commands must be discovered from each target repository rather than assumed by this pack.
    • The skills are workflow instructions, not a guarantee that an agent can run commands or access every tool in every environment.

    Recommended next step: install the pack in a compatible coding agent and run codebase-index against a real application repository. Then use scope-plan or solution-architect to turn the findings into the next engineering task.

    CODEBASE_INDEX.md

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

    About this skill

    The Agent Engineering Workflow Pack gives AI coding agents a set of 13 focused workflows for real software engineering work. Instead of relying on one oversized prompt, it separates planning, codebase discovery, architecture, implementation, debugging, verification, testing, review, documentation, and project-context maintenance into specialist skills.

    Use scope-plan to turn an idea into an ordered feature plan. Use codebase-index to understand an unfamiliar repository, and codebase-audit to establish portable AGENTS.md project context. context-forge creates enforceable working rules; rules-generator remains available when a standalone RULES.md is specifically needed.

    When a feature needs important technical decisions, solution-architect creates the specification. feature-build implements from that specification and the project's conventions. fault-fix investigates defects from reproducible evidence and applies minimal fixes. verify-release checks observable behavior, test-engineer writes regression coverage, and peer-review performs an independent review of the change set.

    tech-writer drafts pull request descriptions, changelogs, release notes, and postmortems from the actual change record. state-sync reconciles durable project context, scope, and specification status after meaningful changes.

    The skills can be used independently or combined into a workflow. You do not need to run all 13 for every task. The pack is intended for existing software repositories and new projects where the agent has access to relevant project files. Some skills can modify project files or code, so review diffs and keep normal version-control safeguards in place.

    The pack follows the open Agent Skills format. It requires a compatible coding agent with repository file tools; terminal and Git access are recommended. Browser access and sub-agent support are optional and depend on the agent. No external account, API key, paid service, or MCP server is required for the core workflows.

    This is an open-source distribution under the MIT License. The source repository is https://github.com/afuhflynn/agent-skills. The listing provides a packaged copy for convenient access through Agensi; it is not an exclusive or proprietary edition.

    Requires file system access (bash, grep, glob). Heavy architectural shifts may require manual spec verification. Does not support incremental updates for some rule generation tasks.

    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

    3 uses

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 13 days ago

    • Free with an Agensi account

    Requires

    Terminal access
    Git
    Node.js
    macOS
    Python

    Permissions

    Terminal / Shell
    Browser
    Network Access
    Read Files
    Write Files

    Some skills are read-only on source code; others create documentation or modify code. Review proposed changes and diffs. Browser and network access are only needed for tasks that call for external research or HTTP/browser verification. No environment variables or credentials are required by the pack itself.

    Listed13 days ago

    What's inside

    Frequently Asked Questions

    The pack includes 13 specialized engineering skills ranging from codebase auditing and rule generation to feature building and automated documentation maintenance. These are provided as standardized skill definitions that can be imported into your agentic workflow.

    This suite is language-agnostic and compatible with any AI interface that supports tool-calling or skill execution, such as Claude Code, Cursor, and GitHub Copilot. It works across any tech stack by utilizing universal CLI tools like bash and grep to index your files.

    The workflow solves 'context drift' by using an evidence-first approach. Instead of relying on an agent's memory, tools like /codebase-audit and /state-sync force the AI to verify the current state of your code before proposing changes or writing documentation.

    Setup is straightforward; once imported, you typically begin by running the /codebase-audit skill. This initializes an AGENTS.md file in your repository which serves as the 'source of truth' for all subsequent agent interactions and feature builds.

    While the skills automate the heavy lifting of drafting specs and code, we recommend a 'human-in-the-loop' approach for major architectural shifts. The /peer-review skill is designed to facilitate this by presenting diffs for your approval before they are merged.

    Yes, purchasers receive access to version updates as the workflow is refined for newer LLM capabilities. Documentation for the latest skill definitions and any changes to the execution flow are provided through the marketplace dashboard.

    New in Agents & Orchestration