Works with the AI Agents you already use
Claude Code
Cursor
Codex CLI
Muse
Dots+21 moreClaude CodeCursorCodex CLIMuseDots
Manus
Grok
Grok Bot+18 agentsDevAssistant: Architecture Guardian & Persistent Memory
Senior software architect for enforcing Hexagonal & Screaming Architecture boundaries, running real-time import audits, scaffolding feature blueprints, and persisting project decisions in local SQLite across sessions.
$12
DevAssistant: Architecture Guardian & Persistent Memory
Example session with this skill installed
I need to add a new 'billing' module to the 'nexus-api' project. Please check the architecture and generate a blueprint for a Hexagonal implementation.
- Read your context and instructions
- Compiled the devassistant
I have inspected the nexus-api project and recalled existing memories regarding the FastAPI stack and Pydantic v2 preferences. I am scaffolding the billing module using Hexagonal Architecture patterns to ensure domain isolation.
Feature Blueprint: billing
| Layer | Directory Path | Responsibility |
|---|---|---|
| Domain | src/core/billing/domain/ | Pure business logic and entities (zero dependencies) |
| Ports | src/core/billing/ports/ | Abstract repository and service interfaces |
| Use Cases | src/core/billing/use_cases/ | Application orchestration and business flows |
| Adapters | src/infrastructure/adapters/billing/ | Database implementations (SQLAlchemy) and API routes |
# src/core/billing/ports/i_billing_repository.py
from abc import ABC, abstractmethod
class IBillingRepository(ABC):
@abstractmethod
async def save_invoice(self, invoice: dict) -> str:
pass
Next steps
- I will now create the directory structure and initialize the abstract port interfaces.
- After implementation, I will run
audit_architectureto ensure no infrastructure leaks into the domain layer. - I will record the chosen payment provider in the project memory for future sessions.
Connects securely to your tools. The creator never sees your data.
About this skill
Maintaining architectural integrity across multi-session coding tasks is difficult when context window resets wipe out previous technical decisions. This skill provides an autonomous software architecture guardian that enforces Hexagonal and Screaming Architecture patterns while persisting ADRs, project constraints, and developer preferences in a sovereign local SQLite database.
What it does
- Architectural Auditing performs automated boundary checks to ensure domain logic remains isolated from infrastructure frameworks like FastAPI or SQLAlchemy.
- Persistent Memory stores and recalls technical decisions, client requirements, and coding preferences across different sessions using a local database.
- Feature Blueprinting generates standardized directory and file structures for new modules based on detected project stacks.
- ADR Generation exports stored architectural decisions directly into Markdown files to keep project documentation in sync with development.
- Stack Inspection identifies project patterns in Next.js, FastAPI, Astro, and React to provide context-aware scaffolding and reviews.
How it works
- Context Recall retrieves prior memories and inspects the current project structure to establish architectural constraints.
- Feature Scaffolding generates a blueprint for new domain entities or UI modules following strict Hexagonal or Screaming patterns.
- Boundary Enforcement runs audits after code changes to catch forbidden imports that violate layer isolation rules.
- Decision Persistence records new architectural trade-offs or developer preferences into the local memory store for future sessions.
Frameworks & tools
This skill is designed for full-stack environments including FastAPI, Next.js, Astro, React, and Streamlit. It utilizes a local SQLite database for sovereign memory persistence and integrates with the dev-assistant MCP server.
Why this beats prompting it yourself
Standard prompts lose context the moment a session ends, leading to architectural drift and repeated mistakes. This skill automates the boring parts of layer enforcement and ensures that a decision made last week is still enforced today without manual re-entry.
Use cases
- Enforcing Hexagonal architecture by preventing framework leaks into the core domain logic.
- Maintaining consistent feature folder structures in large Next.js or Astro monorepos.
- Building a persistent knowledge base of client-specific business rules and technical trade-offs.
- Auto-generating ADR documentation for team review based on real-time coding decisions.
Known limitations
Requires the dev-assistant MCP server to be installed and configured with a valid WORKSPACE_ROOT. Memory persistence is local to the SQLite database path defined in the environment.
Requires the dev-assistant MCP server and a local SQLite database setup. Enforcement is focused on Hexagonal and Screaming Architecture patterns.
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 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 today
Requires
PythonPermissions
Requires read/write access to inspect architecture files, scaffold blueprints, and persist local SQLite memories. No external network required.