SIDDARTHA577/envguard-node / .agents/skills/envguard-senior-engineer-review
envguard-senior-engineer-review
VerifiedFlagship senior software architect review coordinating full-stack discovery, system design assessment, multi-adapter verification, capacity planning, SRE reliability analysis, and ADR generation.
envguard-senior-engineer-review Skill
EnvGuard's flagship senior engineering and architecture review capability. Operates as an integrated principal software architect and staff engineering team reviewing complete multi-tier applications across web frontends, mobile clients, backend APIs, distributed databases, message queues, container infrastructure, and CI/CD pipelines. Evaluates 17 primary system design concepts, identifies architectural bottlenecks and failure modes, executes authorized verification checks, formulates reviewable Architecture Decision Records (ADRs), and generates comprehensive pre-deployment engineering reports.
When to Trigger
- Conducting a comprehensive, end-to-end architectural review of an application or monorepo before production deployment.
- Evaluating system design scalability, failure modes, and capacity requirements for expected traffic growth.
- Reviewing complete multi-tier systems across frontend, mobile, backend API, database, and cloud infrastructure.
- Determining whether an architecture is appropriately designed or overengineered for current team size and requirements.
- Generating formal Architecture Decision Records (ADRs) to remediate identified architectural risks.
When NOT to Trigger
- Conducting quick single-file lint or type checks (use native
tscoreslint). - Auditing environment variables exclusively for secret leakage (use
envguard-auditorenvguard-review). - Writing raw database SQL migration scripts in isolation (use
envguard-database). - Conducting focused WCAG screen reader accessibility testing without architectural scope (use
envguard-accessibility).
Supported Projects & Environments
- Full-Stack & Monorepo Targets: Web frontends (React, Next.js, Vue), Mobile clients (React Native, Expo, Flutter, Native Android, Native iOS), Backend services (Express, Fastify, NestJS, Django, FastAPI, Flask, Spring Boot), and shared packages.
- Datastores & Infrastructure: PostgreSQL, MySQL, SQLite, MongoDB, Redis, RabbitMQ, Kafka, Docker, Kubernetes, GitHub Actions.
- Runtimes: Node.js (22.x, 24.x, 26.x), Python (3.10+), Java (17, 21, 25 LTS), Dart (3.x), Swift, Kotlin.
- Operating Systems: Linux, macOS, Windows (native macOS builds/tests transparently evaluated as NOT_RUN on non-macOS hosts).
Required Tools & Permissions
- Tools:
read_file,write_file,run_command. - Permissions:
- Read-only workspace permission by default for static architecture discovery and system design evaluation.
- Workspace write permission when saving generated ADRs, remediation patches, or engineering reports.
- Explicit execution authorization (
--allow-exec --trust-project) required before running any local test suite or benchmark runner.
- Safety Boundaries: Never executes destructive chaos tests, credential extraction, or unauthorized remote load tests.
Expected Inputs
projectDir: Path to the project root directory or monorepo root (default'.').requirements: Optional object specifying expected users, traffic estimates (RPS, DAU), availability targets, latency targets, and team size.allowExec: Boolean flag to permit running declared test suites (defaultfalse).trustProject: Explicit host trust acknowledgment for unisolated environments (defaultfalse).format: Output format:'json','markdown', or'both'(default'both').outputDir: Directory to write generated reports and ADRs (e.g.docs/adr/,.envguard/reports/).
Step-by-Step Workflow
Stage 1: Repository & Requirement Discovery
- Collect or infer project requirements using
discoverArchitectureRequirements:- Product purpose and critical user journeys.
- Availability targets (99.9% vs 99.99%) and latency objectives (p95 < 200ms).
- Team size and budget posture (never inventing traffic metrics; missing workload data is flagged as unknown).
- Build comprehensive architectural inventory using
buildArchitectureInventory:- Classify topology:
modular-monolith,microservices,mobile-client-backend, orstandalone. - Identify frontend clients, backend services, datastores, caches, queues, and container definitions.
- Classify topology:
Stage 2: Specialized Adapter & Skill Routing
- Route project modules to specialized EnvGuard adapters:
- Node/TypeScript services ->
NodeTypeScriptAdapter. - Next.js / React clients ->
NextJsReactAdapter. - Python backends ->
PythonAdapter. - Java Spring Boot services ->
JavaSpringBootAdapter. - Mobile clients ->
ReactNativeAdapter,FlutterAdapter,AndroidAdapter,IosAdapter.
- Node/TypeScript services ->
- Hand off deep domain concerns to complementary skills:
- REST/OpenAPI contracts ->
envguard-api-design. - Database schemas & indexes ->
envguard-database. - UI tokens & component hierarchy ->
envguard-ui-design. - Screen reader a11y ->
envguard-accessibility.
- REST/OpenAPI contracts ->
Stage 3: System Design Matrix Evaluation (17 Mandatory Dimensions)
- Evaluate applicability and implementation state for all 17 primary system design concepts using
evaluateSystemDesignDecisions:- Load Balancing, Caching, CDN, API Gateway, Microservices, Monolithic Architecture, Replication, Partitioning/Sharding, Message Queues, Rate Limiting, Consistent Hashing, CAP Theorem, Horizontal Scaling, Vertical Scaling, Fault Tolerance, Circuit Breaker, Event-Driven Architecture.
- Flag defects (e.g. unbounded memory caches, missing rate limiting, missing health checks) and overengineering (e.g. microservices for 2-person teams).
Stage 4: Scalability, Reliability & Capacity Modeling
- Model architectural tradeoffs using
evaluateArchitectureTradeoffs(Simplicity vs Scalability, CAP consistency, Cost vs Redundancy). - Perform Failure Mode and Effects Analysis (FMEA) using
analyzeFailureModes(SPOF, connection pool exhaustion, cache stampede, downstream timeout cascades). - Generate capacity model and hypothetical 10,000-virtual-user scenario using
buildCapacityModel. - If authorized, execute safe local performance baselines using
runLocalBenchmark.
Stage 5: Architecture Decision Records (ADRs) & Remediation
- Formulate structured, reviewable ADR drafts using
generateArchitectureDecisionRecords:- Document Context, Problem, Alternatives, Recommendation, Tradeoffs, Costs, Risks, and Rollback Strategy.
- Prepare minimal, reviewable code/config patches for high-severity findings upon user request.
Stage 6: Unified Engineering Report Emission
- Compile unified engineering report containing Executive Summary, Topology Map, System Design Matrix, Reliability & FMEA analysis, Capacity Model, and ADRs.
- Evaluate release policy gates (block release on any critical security or stability failure).
Validation Steps
- Verify architecture inventory accurately discovers all declared services, datastores, and queues.
- Verify system design evaluations adhere to applicability rules (never penalizing small monoliths for lacking Kafka or Kubernetes).
- Verify capacity models clearly distinguish hypothetical projections from observed measurements.
- Verify all 17 system design dimensions produce deterministic evaluations across test fixtures.
- Verify generated ADRs contain all required architectural sections.
Expected Outputs
- Unified Engineering Report (
readiness-report.md&readiness-report.json): Comprehensive production readiness assessment covering architecture, security, tests, and deployment. - Architecture Decision Records (
docs/adr/ADR-*.md): Reviewable markdown decision records for required architectural changes. - Capacity & Performance Plan: Resource sizing projections and k6 stress testing configuration templates.
Failure Handling
- Missing Architecture Documentation: Record explicit assumptions with confidence ratings (
low_heuristic); proceed with static code analysis. - Incompatible Platforms: Transparently report platform-dependent checks as
NOT_RUNwith prerequisite instructions. - Policy Blockers: Identify critical architectural and security blockers with clear P0 remediation instructions.
Safety & Privacy Boundaries
- No Production Load Testing: Load tests and stress profiles must never be executed against production endpoints without explicit human approval.
- No Destructive Operations: Never drop databases, execute unverified migrations, or wipe storage during assessment.
- Credential Protection: Keystores, private signing certificates, and cloud credentials are never inspected or exported.
Example User Prompts
- "Review my complete application as a senior software architect before production deployment."
- "Evaluate our full-stack architecture, identify scalability bottlenecks, and generate pre-deployment ADRs."
- "Assess whether our current backend architecture can handle expected traffic growth or if we need caching and read replicas."
- "Conduct an integrated senior engineering review of our monorepo (Expo mobile + Express API + PostgreSQL)."
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation). | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK). | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |