Architect

Best practices for your stack.
Anti-patterns caught. Zero config.

Point it at an existing vibe-coded project, pick your agent, and Architect installs three slash commands that teach your agent the best practices, separation rules, and anti-patterns for your exact stack.

$npm install -g @levironexe/architect

Please install architect https://leviron-architect.vercel.app/prompt.txt

Quickstart

Zero API key friction.

No provider setup. No ANTHROPIC_API_KEY, no OPENAI_API_KEY. Architect runs local static analysis to detect your stack and generates agent-ready skill files. The coding agent you already have IS the intelligence - Architect gives it the right knowledge to act on.

View supported agents

$ npm install -g @levironexe/architect

$ cd my-messy-express-app

$ architect init . --integration claude

✓ Detected stack: Express.js REST API

✓ Detected agent: Claude Code

✓ Installed 3 skills:

/architect-plan → .claude/skills/architect-plan/

/architect-refactor → .claude/skills/architect-refactor/

/architect-catchup → .claude/skills/architect-catchup/

Open Claude Code and run /architect-plan to get started.

Rescue existing projects.

Architect is for the developer who already has a messy project. It's the ER room, not the gym.

Initialize

Walks the project directory, respecting .gitignore. Runs local static analysis - file sizes, import graphs, circular deps, duplication - without uploading your code.

Analyze

Detects your tech stack from package.json and file patterns, matching it to a community-defined skill (e.g., Express API, Next.js App Router). Override with --skill if needed.

Install Skills

Renders three slash command files with the matched blueprint and static analysis context embedded, writing them directly to your agent's config directory.

The Gap

The Spaghetti Point.

“Vibe-coded projects accumulate technical debt fast. AI-generated code optimizes for ‘make it work,’ not ‘make it maintainable.’”

Nobody installs stack-specific architectural knowledge into a coding agent for an existing project, automatically. Architect fills that gap.

Capability	Sonar / ESLint	CLAUDE.md / .cursorrules	Architect
File-level code quality checks	✓	-	-
Custom rule mechanism	-	✓	-
Existing codebase architecture scan	-	-	✓
Stack auto-detection	-	-	✓
Stack-specific architecture blueprint	-	-	✓
Stack-specific best practices	-	-	✓
Anti-pattern detection with fix examples	-	-	✓
Auto-generated assistant instructions	-	-	✓
Refactor-phase guidance for messy projects	-	-	✓

How Architect Builds Context

When your agent asks for context (usually via architect context), Architect picks the right stack blueprint and returns clear guidance for how your project should be organized.

What You Provide

Your project (and optionally a stack hint)

→

↓

What Architect Does

Detects the stack and loads the matching architecture rules

→

↓

What You Get

A clear blueprint your agent can follow

Three slash commands. Full control.

Architect installs three specific skills that guide your agent through a structured, predictable refactoring process based on the installed stack blueprint.

The agent is the intelligence. Architect gives it the map.

/architect-plan

Roadmap Generation

The agent walks the codebase, calls architect context to load the full blueprint, compares current structure against it, and writes a phased refactoring roadmap to .architect/plan.md.

Compares current structure to blueprint
Identifies concrete steps (source file → target file)

/architect-refactor

Guided Execution

The agent reads .architect/plan.md and executes each phase step by step, pausing after each phase to wait for your confirmation before continuing.

Follows separation rules as hard constraints
Explains every action during execution

/architect-catchup

Skill Refresh

After you add new code, the agent re-scans the project and refreshes installed skills so guidance stays aligned with the current codebase state.

Re-runs project scan and stack detection
Rewrites skills with fresh architecture context

Principles

Real engineering principles.
Not generic advice.

Every skill is grounded in battle-tested software engineering principles — your agent doesn't guess, it follows the blueprint.

Separation of Concerns

Your agent learns which code belongs where — routes, services, models, middleware — and enforces boundaries.

SOLID Principles

Single Responsibility, Open-Closed, Interface Segregation, and Dependency Injection — taught per stack.

Layered Architecture

Route → Controller → Service → Model. Every stack gets its own data flow blueprint with strict layer rules.

DRY

Duplicate code detected and eliminated. Shared logic extracted into reusable hooks, utilities, and modules.

Security Patterns

Secrets from environment only. Auth middleware enforced. Input validated. RLS policies on every table.

Error Handling

Typed errors, fail-fast validation, no empty catch blocks. Resilient patterns from day one.

API Contracts

Clean DTOs, separate input and output schemas, typed responses. Your API surface stays predictable.

Testability

Services accept plain data, not HTTP objects. Every layer independently testable without mocking the world.

Config Management

Environment validated at startup via schema. No scattered process.env reads. One source of truth.

Built-in Skills

Skills follow the open Agent Skills standard — a SKILL.md file per stack with detection rules, folder structure blueprints, and anti-pattern guidance. Community-extensible.