Professional Project Intake

Purpose

⚠IMPORTANT⚠This skill enforces deterministic project initialization heuristics. It strictly prohibits immediate recursive code generation, mandating a preliminary constraint validation, stack topology extraction, and file tree DAG (Directed Acyclic Graph) formulation.

When to Use This Skill

⚠NOTE⚠Use this skill when the user asks you to build a new project, start a new app, or build a major new system from scratch.

What This Skill Prevents

This skill prevents:

• Zero-Context AST Interpolation: Emitting generic DOM structures before verifying framework topology.
• Dependency Hallucination: Inferring execution stacks without statically analyzing module schemas (e.g., package.json).
• Unscalable Topologies: Applying $O(N)$ flat directory architectures to applications requiring $O(\log N)$ hierarchical feature splitting.
• Underspecified State Vectors: Proceeding with execution while lacking critical parameters (Auth layers, DB drivers).

Core Principle

Enforce pre-execution environment static analysis. Code generation operations MUST remain blocked until stack dependencies are computed and architecture invariants are strictly bounded to the target scale.

Research-Backed Rules

• Pre-Flight Constraint Analysis: Agent MUST parse core definition files (package.json, tsconfig.json, docker-compose.yml) prior to instantiating code generation algorithms.
• Sub-System Parity: Unfulfilled dependency branches (e.g. absent backend nodes) MUST trigger explicit architecture mapping, not synthetic UI mocking.
• Execution Bound Assertions: Explicit state machine boundaries and structural scopes MUST be declared in the initialization phase.

Stack-Aware Guidance

React / Next.js Guidance

Assert Router Topology (app/ vs pages/). Differentiate AST rendering boundaries (Server Components vs. Client Components). Assert styling engine dependencies.

Vue / Nuxt Guidance

Verify composition boundaries (Composition API, Pinia stores). Ensure deterministic component lifecycle hook implementations.

Backend / API Projects Guidance

Evaluate ORM layer integration vectors (Prisma, Drizzle, SQLAlchemy). Instantiate deterministically normalized relational or document models.

File Tree Guidance

Enforce $O(1)$ lookup complexity by isolating concerns into orthogonal branches:

• routes/ (Execution endpoints)
• ui/ (Stateless generic render nodes)
• models/ (Data domain definitions)
• services/ (Business logic singletons)
• utils/ (Pure function transformations)
• config/ (Environment invariants)

Implementation Guidance

1. Execute Static Analysis: Traverse directory structure via ls -la or tree. Parse underlying configuration files (package.json, tsconfig.json).
2. Compute Dependency Matrices: Segregate the input prompt parameters into orthogonal layers (Frontend, Backend, Data, Infrastructure).
3. Generate Topological Plan: Output a strict, deterministic schema defining state management vectors, routing hierarchies, and persistent storage protocols.
4. Resolve Ambiguity Vectors: If input parameters contain unresolvable unknowns (e.g., "dashboard" missing data source), halt execution and emit a state resolution query.
5. Architectural Decision Matrix (ADR): Append execution path choices and tradeoffs into docs/adr/. State constraints, vectors evaluated, and algorithmic choice.

Quality Gates

Visual Quality Gate

• Confirmed UI framework constraints and styling primitive variables.

Maintainability Gate

• Confirmed structural scaling thresholds ($N \rightarrow \infty$).
• Nullified reliance on unstable or temporary mock states.

Anti-Patterns to Avoid

• Raw File Dumps: Emitting unstructured static assets instead of compiled module bundler configurations.
• Phantom State Resolution: Satisfying conditional logic with empty vectors instead of rigorous backend state derivations.
• Implicit Requirement Failure: Omitting SEO/SSR optimizations on targets explicitly requiring crawler-friendly DOM generation.

Agent Behavior Instructions

1. Engage pre-flight scan of local FS variables.
2. Formulate constraint graph (Stack, Topography, State Matrix).
3. Halt execution pending parameter verification.
4. Extrapolate missing parameters based on standard architectural axioms.

Final Review Checklist

• No unbounded DOM generation.
• All stack constraints verified.
• DAG hierarchy explicitly defined.
• Fully agent-optimized deterministic rules.