More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    software engineer

    1

    A senior-level engineering skill for planning, building, and maintaining professional software and AI agent systems.

    $15

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    software engineer

    Example session with this skill installed

    I want to create a catalog software for my shop that allows me to manage my orders and store my products, with Google Maps integration to track deliveries to customers' homes. How can you help?

    • Read your context and instructions
    • Compiled the software engineer

    I can help you build this end to end — from defining the scope to a working, deployed app. Before writing code, we need to pin down
    what "track deliveries with Google Maps" should actually mean, because that single choice changes the cost and complexity a lot.

    My working assumptions: one shop, your own delivery staff, and a web app usable on a phone (no app-store install needed for v1).
    Correct me if any of that is wrong.

     What the app would cover
    
     - Catalog & stock — products with photos, prices, categories, stock levels, low-stock alerts.
     - Orders — create and track orders (new → preparing → out for delivery → delivered), customer records, order history, delivery
       addresses.
     - Deliveries on a map — stops shown on Google Maps, the day's route, and a simple driver view on a phone.
     - Access control — owner, staff, and optionally drivers each see only what they need.
    

    The key distinction: "tracking" has three levels

     ┌────────────────────────────────────┬──────────────────────────────────────────────────────────────────────┬─────────────────────────┐
     │ Level                              │ What you or the customer sees                                        │ Complexity              │
     ├────────────────────────────────────┼──────────────────────────────────────────────────────────────────────┼─────────────────────────┤
     │ 1. Address map                     │ Customer's home pin and address, maybe a route                       │ Low                     │
     ├────────────────────────────────────┼──────────────────────────────────────────────────────────────────────┼─────────────────────────┤
     │ 2. Delivery planning               │ All stops on a map, best order, driver checklist                     │ Medium                  │
     ├────────────────────────────────────┼──────────────────────────────────────────────────────────────────────┼─────────────────────────┤
     │ 3. Live tracking                   │ Driver's real-time position, customer sees "5 min away"              │ High                    │
     └────────────────────────────────────┴──────────────────────────────────────────────────────────────────────┴─────────────────────────┘
    
     Google Maps provides maps, address lookup (geocoding), and directions. It does not know where your driver is. Level 3 requires the
     driver's phone to send its GPS position to our backend, plus a secure customer tracking page. It's doable, but it's a separate feature
     with privacy and battery implications — I'd build it after the core works.
    
     How I'd approach it
    
     1. Scope — a one-page v1 scope: what's in, what's out, success criteria.
     2. Simple architecture — one responsive web app plus a database. No microservices for a single shop.
     3. Build in testable slices — catalog → orders → delivery map → live tracking (optional).
     4. Verify and deploy — tests, a staging check, then production. I'll ask before anything that costs money (hosting, Google Maps
        billing) or touches customer data.
    

    Two practical notes

     - Google Maps Platform needs an API key linked to a billing account. There's a free monthly allowance, then pay-per-use; I'll confirm
       current rates before enabling it and design the app to keep calls low.
     - Customer addresses and phone numbers (and driver location, if live tracking) are personal data. I'll include access control, expiring
       tracking links, and minimal retention.
    
     There's no existing project in /root, so we start clean. A few questions to scope it properly:
    

    Audit and fine-tuning

    CategoryDetails
    Current StateFastAPI v0.104, SQLAlchemy 2.0, PostgreSQL. Existing user models found in app/models/user.py.
    ImpactModifies app/api/v1/endpoints/users.py, adds app/schemas/user.py update models.
    RisksPotential PII exposure in logs; requires strict validation for the bio and avatar_url fields.
    AssumptionsUser ID is extracted from the JWT token; no change needed to existing Auth middleware.

    Phase 3: Implementation Plan

    1. Schema Definition
       - Create `UserUpdate` Pydantic schema in `app/schemas/user.py`.
       - Add validation for optional fields (bio, location, website).
    
    2. CRUD Logic
       - Implement `update_user` function in `app/crud/crud_user.py`.
       - Ensure partial updates (PATCH semantics) are supported.
    
    3. API Endpoint
       - Add `PATCH /users/me` to `app/api/v1/endpoints/users.py`.
       - Integrate dependency injection for current_user.
    
    4. Verification
       - Write unit test in `tests/api/test_users.py`.
       - Verify 200 OK on valid data and 422 on invalid schema.
    

    Next steps

    1. Approve the UserUpdate schema fields (bio, location, website).
    2. Confirm if we should trigger a background task for avatar processing.
    3. Verify if the database migration for the new location column has been applied.

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

    About this skill

    Stop treating your AI as just a code generator and start using it as a senior engineer. This skill moves beyond simple autocomplete by enforcing a rigorous engineering lifecycle that covers discovery, architecture, implementation, and verification. It manages technical debt and operational risk by requiring explicit requirements and Architecture Decision Records (ADRs) before a single line of code is written.

    What it does

    • Technical discovery conducts deep repository audits to identify architectural patterns, risks, and constraints before proposing changes.
    • Requirement engineering defines functional and non-functional requirements with measurable targets and clear acceptance criteria.
    • Architectural design creates system context models and data flows, documenting significant choices through formal ADRs.
    • Controlled implementation executes vertical slices of work following SOLID, DRY, and KISS principles while maintaining project-specific conventions.
    • Multi-level verification runs unit, integration, and security checks, providing evidence-based reports of test success or failure.
    • Operational readiness prepares release notes, migration paths, and runbooks for production-grade deployments.

    How it works

    1. Triage and audit the existing codebase and documentation to establish a baseline of facts and risks.
    2. Define the problem space by drafting a project brief and requirements list for human approval.
    3. Design the solution using the included engineering document pack to map out components and interfaces.
    4. Iterate through implementation with dependency-aware tasks and integrated testing at every step.
    5. Finalize and report with a comprehensive summary of changes, verified test results, and residual limitations.

    Frameworks & tools

    This skill is framework-agnostic and adapts to your existing stack. It includes specialized support for Google ADK (Agent Development Kit) and enterprise-scale agent systems. It uses Python 3 for internal auditing scripts.

    Why this beats prompting it yourself

    Standard prompting often results in "vibe-coding" where the AI skips discovery and creates technical debt. This skill enforces a structured engineering process that prioritizes maintainability and security over quick, brittle fixes. It ensures that every change is backed by a recorded decision and verified against your actual business goals.

    Use cases

    • New product scaffolding from initial problem discovery to a production-ready MVP.
    • Complex refactoring of legacy systems where architecture decisions must be documented.
    • AI agent integration using Google ADK to build reliable tool-calling systems.
    • Security hardening and threat modeling for high-risk enterprise applications.

    Known limitations

    Requires filesystem access to read and audit the repository. Does not perform irreversible data migrations or production deployments without explicit manual approval at defined gates.

    While it doesn't yet cover all the skills of a fully-fledged engineer, version 2 is on its way.

    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

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 5 days ago

    Requires

    Python
    Node 18 +

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Browser
    Environment Variables
    Listed5 days ago

    What's inside

    Frequently Asked Questions

    Unlike standard prompts that generate code snippets in isolation, this skill enforces a full software development lifecycle including discovery, ADR documentation, and multi-level verification to prevent technical debt.

    The skill is framework-agnostic and works with any codebase, though it features specialized optimizations for Google ADK (Agent Development Kit) and enterprise-scale agent architectures.

    The skill requires filesystem access to audit your repository and execute internal Python-based auditing scripts to establish an architectural baseline.

    You receive the complete engineering workflow logic, a suite of internal auditing scripts, and the standardized engineering document pack for requirements and ADRs.

    No, the skill is designed with safety gates that require explicit manual approval for all architectural decisions and deployments, ensuring you maintain full control over your production environment.

    This skill is ideal for complex refactoring of legacy systems, building production-ready MVPs from scratch, and implementing secure, tool-calling AI agents.

    New in Prompt & Skill Engineering