Agent coding and workflow rules

    1

    A structured coding workflow for agents that enforces task planning, atomic commits, and rigorous coding standards.

    $9.99

    /mo

    Subscription · cancel anytime

    Secure checkout via Stripe

    • Always the latest version
    • Delivered live to your agent via MCP
    • Cancel anytime, access ends at period end
    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+22 more

    Agent coding and workflow rules

    Example session with this skill installed

    Implement a new user registration flow in the existing auth domain, following the task workflow.

    • Read your context and instructions
    • Compiled the agent coding

    I have analyzed the current authentication domain and initialized the task workflow. I identified that the UserService and AuthController are the primary files for this change. I have created the necessary directory structure and task files to track the implementation of the registration flow, including validation and password hashing.

    Task Planning Initialization

    File PathPurposeStatus
    .agent/tasks/agent-user-reg/task_context.mdResearch on AuthService patterns and DTOsplanned
    .agent/tasks/agent-user-reg/task_1.mdImplement UserRegistrationDto and validation logicplanned
    .agent/tasks/agent-user-reg/task_2.mdUpdate UserService with register method and hashingplanned
    .agent/tasks/agent-user-reg/task_3.mdAdd POST /auth/register endpoint to AuthControllerplanned
    
# task_context.md
## Research Findings
- The project uses a Repository pattern for database access.
- Existing auth flows use `Bcrypt` for hashing; must stay consistent.
- `ValidationPipe` is globally enabled in `main.ts`, so DTO decorators are required.

## Key Files
- `src/users/user.service.ts`
- `src/users/user.controller.ts`
- `src/auth/auth.service.ts`

    Next steps

    1. I will now place // [PLAN] comments in user.service.ts and user.controller.ts to anchor the implementation.
    2. I will commit these planning artifacts to the agent/user-reg branch.
    3. I will begin implementation of Task 1 (DTO and Validation).
    $9.99/mo

    Subscription · always the latest version

    • Secure checkout via Stripe
    • Cancel anytime
    • Delivered live via MCP (optional)

    About this skill

    Managing complex codebases without a plan leads to regression, broken patterns, and technical debt. This skill enforces a strict, atomic workflow that ensures every change is researched, planned, reviewed, and documented before it ever hits a main branch. It turns haphazard coding into a repeatable process of structured tasks and commits.

    What it does

    • Task Orchestration by breaking large features into atomic task files with specific acceptance criteria and status tracking.
    • Architectural Enforcement by following Domain-Driven Design and SOLID principles tailored to your project's existing paradigm.
    • Automated Planning using [PLAN] anchors in the codebase to map out changes before writing a single line of logic.
    • Rigorous Review through a subagent-driven process that checks for null safety, error handling, and thought-chain commenting.
    • Knowledge Persistence by maintaining a .agent/knowledge/ directory to capture architectural decisions and project-specific gotchas.

    How it works

    1. Research & Plan: Analyze the codebase, create .agent/tasks/ files for the specific branch, and mark change locations with // [PLAN] comments.
    2. Implement: Execute tasks one by one, using one commit per task and updating statuses from planned to implemented.
    3. Review & Test: Trigger a subagent review against coding standards and run tests to verify acceptance criteria; failed tests move tasks back to replan.
    4. Document: Update the README and knowledge files to reflect architectural changes or new features after code is verified.

    Frameworks & tools

    This skill is language-agnostic and adapts its error handling and null-safety checks to the idiomatic standards of TypeScript, Python, Go, Rust, Kotlin, Swift, C#, and Java.

    Why this beats prompting it yourself

    Generic prompts often result in "lazy" coding where the agent ignores existing utilities or creates massive, undocumented functions. This skill forces a commit-by-commit workflow and mandates internal "thought-chain" comments, ensuring the resulting code is as maintainable as if a senior dev wrote it.

    Use cases

    • Refactoring core modules where side effects must be meticulously tracked across multiple files.
    • Implementing new features that require strict adherence to existing DDD or functional patterns.
    • Managing complex bug fixes that span several service layers and require detailed regression testing.
    • Onboarding an agent to a legacy repository where project-specific knowledge must be documented as it is discovered.

    Known limitations

    Requires a project structure that allows for a .agent/ directory at the root. The review step works best when the environment supports subagent spawning.

    How to use

    Skills on Agensi run inside your AI agent. Copy the prompt, paste it into your agent, and it connects to Agensi and installs this skill for you. If a payment is needed, your agent shows it to you first.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill passes our trust checks below.

    Security scanned

    Passed our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scanned

    Verified clean 1 day ago

    Listed1 day ago

    What's inside

    Frequently Asked Questions