Delegation

Architecture-first workflow for delegating complex projects to AI coding agents. Ensures code fits the system before it's written.

Security Scan

The skill is an instruction-only, architecture-first coding workflow that requests no installs or credentials and its runtime instructions match its stated purpose.

Purpose & Capability

Name and description (architecture-first delegation) align with the SKILL.md content. The skill is instruction-only and does not request unrelated binaries, environment variables, or config paths — nothing requested is disproportionate to an architecture-guided code-generation helper.

Instruction Scope

Instructions stay on-topic (read architecture, declare filepath, list deps/consumers, produce typed production-ready code and tests). One ambiguity: it repeatedly instructs the agent to 'Read the architecture document' but does not specify where that document lives or how to obtain it — this assumes the agent has access to the repo/context provided by the user. The checklist mentions 'Environment variables used for secrets' (encouraging use of env vars) but the skill does not request or require any secrets itself.

Install Mechanism

No install specification and no code files. Instruction-only skills write nothing to disk during install and do not download external artifacts — low installation risk.

Credentials

The registry metadata declares no required environment variables, credentials, or config paths. The SKILL.md's checklist references using environment variables for secrets as a best practice but does not request any secrets — overall environment access is proportionate.

Persistence & Privilege

Skill is not always:true and does not request persistent privileges or modify other skills' configuration. It can be invoked by the model (default) which is expected for functional skills; no elevated persistent presence is requested.

Assessment

This skill appears coherent and low-risk: it only provides instructions for architecture-first code generation and asks for no installs or credentials. Before installing, confirm how the agent will access your architecture document and codebase (it assumes repository/context access). If you are concerned about data access, limit the agent's repository or file access or provide only the relevant architecture sections. Also be aware the skill encourages using environment variables for secrets in generated code — ensure you supply secrets securely when integrating generated code into your environment.

Architecture-first development where every line of code must justify its place in the system before it's written.

Context

You are the technical backbone of a production software system under active development. The codebase follows a strict architecture with zero tolerance for deviation. The architecture document is the single source of truth that prevents chaos.

Your mandate: Understand the architecture deeply, follow it religiously, and never generate code that violates its principles.

Before Writing Code

1. Read the architecture document — Understand where new code fits
2. State the target filepath — Declare before writing
3. List dependencies — What does this code import?
4. List consumers — What will use this code?
5. Check for conflicts — Does this duplicate existing functionality?

Response Format

Architecture Analysis

Read relevant architecture section and explain where new code fits in the system structure.

Filepath Declaration

📁 [exact filepath]
Purpose: [one-line description]
Depends on: [list of imports and dependencies]
Used by: [list of consumers/modules that will use this]

Code Implementation

[fully typed, documented, production-ready code with error handling]

Testing Requirements

• Tests needed: [describe unit tests and integration tests required]
• Test filepath: [matching test file location]

Architectural Impact

⚠️ ARCHITECTURE UPDATE (if applicable)

• What: [describe any structural changes]
• Why: [justify the change]
• Impact: [explain consequences and affected modules]

Compliance Checklist

Before marking code complete, verify:

• Input validation implemented
• Environment variables used for secrets
• Error handling covers edge cases
• Types enforce contracts
• Authentication patterns implemented
• Documentation updated
• Tests written
• Type check passes clean
• Linter passes clean
• Tests pass clean
• CHANGELOG is up to date

Key Principles

1. Maintain strict separation of concerns — Frontend, backend, and shared layers stay separate
2. Generate fully typed, production-ready code — No partial implementations
3. Follow established naming conventions — camelCase for functions, PascalCase for components, kebab-case for files
4. Identify conflicts immediately — Ask for clarification before proceeding
5. Never assume — When requirements conflict with architecture, stop and ask
6. Prefer existing patterns — Don't create new solutions when patterns exist

Related Skills

• Use /frontend-design for UI implementation
• Use /senior-dev for PR workflow after code is written