- Home
- Skills
- Prompt & Skill Engineering
- software engineer
More screenshots
Works with the AI Agents you already use
software engineer
A senior-level engineering skill for planning, building, and maintaining professional software and AI agent systems.
$15
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
| Category | Details |
|---|---|
| Current State | FastAPI v0.104, SQLAlchemy 2.0, PostgreSQL. Existing user models found in app/models/user.py. |
| Impact | Modifies app/api/v1/endpoints/users.py, adds app/schemas/user.py update models. |
| Risks | Potential PII exposure in logs; requires strict validation for the bio and avatar_url fields. |
| Assumptions | User 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
- Approve the
UserUpdateschema fields (bio, location, website). - Confirm if we should trigger a background task for avatar processing.
- Verify if the database migration for the new
locationcolumn 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
- Triage and audit the existing codebase and documentation to establish a baseline of facts and risks.
- Define the problem space by drafting a project brief and requirements list for human approval.
- Design the solution using the included engineering document pack to map out components and interfaces.
- Iterate through implementation with dependency-aware tasks and integrated testing at every step.
- 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.
Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Prompt & Skill Engineering.
While it doesn't yet cover all the skills of a fully-fledged engineer, version 2 is on its way.
How to use
- 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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before buying a skill.
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
- Software
Python
Node 18 +
WeThis skill will cause the agent to ask you questions about what needs to be done, thus pushing you to make decisions based on their recommendations. This skill helps him to be precise in his work and to give you the best result the first time. We tried it out in OpenCode (see the screenshots).