Lattice

For new projects with Cursor, Claude Code, GitHub Copilot, or Codex

Give Your AI a Real Blueprint Before You Start Coding

Lattice Project Builder turns one product brief into your PROJECT_GUIDE.md, version-locked stack, AI guardrails, CI/CD workflows, and a custom setup command so Cursor, Claude Code, GitHub Copilot, or Codex can build against the same plan.

4-6 hours manual~5 minutes with Project Builder

Start Building With AI See What You Get

Explain it once

Turn one product brief into a project plan instead of re-explaining your app in every new AI chat.

Keep AI aligned

Cursor, Claude Code, GitHub Copilot, and Codex get project-specific rules so they follow your architecture and stack.

Start from a real setup

Get the stack, CI/CD, verification, and the setup command in one package instead of a weekend of setup work.

Cursor + Claude Code + GitHub Copilot + Codex

PAYG available

Cancel anytime

Start in ~5 minutes

Skip the setup rewrite loop

Terminal

# Your custom command from Project Builder

$ npx latticeai --config eyJzdGFjayI6Im5leHRqcy1zYWFzIi4uLn0

OK Created PROJECT_GUIDE.md

OK Wrote .cursor rules + CLAUDE.md

OK Wrote Copilot repo + path instructions

OK Wrote AGENTS.md + docs/rules/codex.md

OK Generated CI/CD + verify workflow

OK Configured a compatible tech stack

Ready to code!

Built for Cursor, Claude Code, GitHub Copilot, and Codex

Project Builder does not stop at a plan. It creates the files each AI editor actually reads, so your prompts, project structure, and code decisions stay aligned even if you switch tools mid-build.

Cursor

Cursor gets both markdown and structured rules, so it stops improvising versions, folders, and architecture decisions.

.cursor/rules.md

.cursor/rules/lattice-core.mdc

Claude Code

Claude Code gets project instructions plus permission and hook scaffolding that match the plan you approved.

CLAUDE.md

.claude/settings.json

GitHub Copilot

GitHub Copilot gets both repo-wide and path-aware instructions, so chat, agent mode, and inline coding stay aligned with the same project blueprint.

.github/copilot-instructions.md

.github/instructions/lattice-core.instructions.md

Codex

Codex gets a clear entrypoint and workflow rules, so it can work inside the same blueprint instead of starting cold.

AGENTS.md

docs/rules/codex.md

How Lattice Project Builder Works

From idea to a stack your AI can actually follow in under 5 minutes.

Describe Your Project in Project Builder

2-3 min

Fill out one form: what you're building, project type (web/mobile/API), key decisions (auth, database, UI style), and planning mode.

Takes 2-3 minutes. The form guides you through the important choices.

AI Generates the Plan + Guardrails

15-90 sec

Lattice AI creates your PROJECT_GUIDE.md, stack plan, AI rules, CI/CD workflows, verification, and editor-specific guardrails.

Supported stack combinations also get scaffolded setup files. If a provider is not wired yet, Lattice keeps your requested stack visible and adds setup notes instead of silently swapping it.

Get Your Custom Command

Instant

Project Builder outputs a single npx command customized for your exact project configuration.

Copy this command. It applies the guide, guardrails, config, and any scaffolded files included for your stack.

Run and Start Coding

30 sec

Paste the command in your terminal. Lattice writes the repo plan, guardrails, and generated setup package automatically.

Supported combinations open with scaffolded app files. Unsupported providers still come with setup notes, so your assistant starts from the right blueprint.

What Project Builder Generates

One brief becomes the plan, the guardrails, and a provider-aware setup package your AI can use immediately.

PROJECT_GUIDE.md

A shared blueprint you and your AI can return to instead of starting every new chat from scratch.

CI/CD + Verify Workflow

GitHub Actions run verify on every push so AI-generated drift gets caught before it lands on main.

Custom Setup Command

One paste applies the guide, rules, config, and generated files for supported stack combinations.

Scaffold + Setup Notes

Supported combinations get scaffolded repo files. When a provider is not wired yet, Lattice keeps it explicit and adds support notes instead of faking the stack.

AI Guardrails Pack

Cursor, Claude Code, GitHub Copilot, and Codex each get the files they actually read: .cursor rules, CLAUDE.md, .github Copilot instructions, AGENTS.md, and docs/rules/codex.md.

Prompt Templates + Checks

Lattice writes reusable prompts plus lint, typecheck, test, build, and verify defaults to keep human and AI changes honest from day one.

Purple = Project Builder-only features |Green = Includes Lattice Core

Example Project Structure

Supported web app combinations can start from a scaffold like this. If a provider needs manual setup, Project Builder still generates the guide, rules, CI, and support notes.

Example supported project structure from Lattice Project Builder

my-saas/
|-- .cursor/rules.md                    # AI guardrails for Cursor
|-- .cursor/rules/
|   |-- lattice-core.mdc               # Structured Cursor rules
|-- .claude/
|   |-- settings.json                  # Claude Code permissions + hooks
|   |-- hooks/                         # Hook templates for policy checks
|-- .mcp.json                          # MCP server template config
|-- .github/
|   |-- copilot-instructions.md        # Repo-wide GitHub Copilot instructions
|   |-- instructions/
|   |   |-- lattice-core.instructions.md # Path-aware Copilot instructions
|   |-- workflows/ci.yml                # CI/CD pipeline
|   |-- PULL_REQUEST_TEMPLATE.md        # PR template
|-- .gitmessage                         # Commit message template
|-- .lattice/
|   |-- config.json                     # Lattice config
|   |-- prompts/                        # 6 prompt templates
|   |   |-- 01-feature.md
|   |   |-- 02-bugfix.md
|   |   |-- 03-refactor.md
|   |   |-- 04-test.md
|   |   |-- 05-polish.md
|   |   |-- 06-security.md
|-- AGENTS.md                           # Codex entrypoint + shared execution policy
|-- docs/
|   |-- rules/
|   |   |-- codex.md                   # Codex-specific workflow rules
|-- CLAUDE.md                           # AI guardrails for Claude Code
|-- PROJECT_GUIDE.md                    # Architecture and milestones
|
|-- app/
|   |-- (auth)/                         # PHASE 1: WORKING AUTH
|   |   |-- layout.tsx
|   |   |-- login/page.tsx              # Login with email/password
|   |   |-- signup/page.tsx             # Signup with email confirmation
|   |   |-- forgot-password/page.tsx    # Password reset
|   |-- (dashboard)/                    # Protected routes
|   |   |-- layout.tsx                  # Dashboard layout with nav
|   |   |-- dashboard/page.tsx          # Dashboard home
|   |-- api/                            # PHASE 4: API ROUTES
|   |   |-- health/route.ts             # Health check
|   |   |-- user/route.ts               # User profile CRUD
|   |   |-- example/
|   |   |   |-- route.ts                # List/Create
|   |   |   |-- [id]/route.ts           # Get/Update/Delete
|   |-- auth/
|   |   |-- callback/route.ts           # OAuth callback
|   |   |-- signout/route.ts            # Sign out
|   |-- layout.tsx                      # Root layout
|   |-- page.tsx                        # Landing page
|   |-- globals.css                     # CSS with theme variables
|
|-- components/
|   |-- ui/                             # PHASE 3: UI COMPONENTS
|   |   |-- button.tsx
|   |   |-- input.tsx
|   |   |-- card.tsx
|   |   |-- spinner.tsx
|   |   |-- index.ts
|
|-- lib/
|   |-- supabase/                       # PHASE 1: AUTH CLIENTS
|   |   |-- client.ts                   # Browser client
|   |   |-- server.ts                   # Server client
|   |-- utils.ts                        # cn() utility
|
|-- supabase/
|   |-- migrations/                     # PHASE 2: DATABASE
|   |   |-- 001_initial_schema.sql      # Profiles table + RLS
|
|-- types/
|   |-- database.types.ts               # Database types
|
|-- proxy.ts                            # Route protection
|-- package.json                        # Full dependencies
|-- tsconfig.json                       # TypeScript config
|-- next.config.ts                      # Next.js config
|-- eslint.config.mjs                   # ESLint flat config
|-- jest.config.js                      # Jest config
|-- jest.setup.js                       # Testing setup
|-- next-env.d.ts                       # Next.js types
|-- .env.example                        # Environment template
|-- .env.local                          # Local env (placeholder)
|-- .gitignore                          # Git ignore
|-- README.md                           # Full documentation

40+ files in supported web scaffold

CI/CD configured

AI guardrails active

Setup notes when needed

40+

Files in Supported Web Scaffold

Prompt Templates

Agent Instruction Packs

AI Coding Without a Plan is Chaos

You've felt it. The AI writes fast, but you spend days fixing what it built wrong.

AI builds the wrong thing

Without clear specs, AI makes assumptions. Wrong assumptions compound into wasted days.

Constant rewrites

You build, realize it's wrong, tear it down, rebuild. The loop never ends.

Dependency chaos

AI suggests packages that don't exist, versions that conflict, patterns that are outdated.

No architecture

Features get bolted on. The codebase becomes unmaintainable. You consider starting over.

Two Planning Modes

Choose the depth that matches your project complexity.

Basic Planning

Fast single-pass generation for straightforward projects. Get your custom command quickly.

PROJECT_GUIDE.md generation
Custom npx bootstrap command
Lattice Core guardrails
CI/CD workflow automation

Included in all paid plans

RECOMMENDED

Pro Planning

Multi-model deliberation for complex projects. Multiple AI models debate and refine your setup.

Everything in Basic
Multi-model AI deliberation
Deeper architecture analysis
Edge case consideration
Enhanced guardrails pack

Included in paid plans (usage depends on plan quota)

Already Have a Project?

If you want to add guardrails to an existing project, Lattice Core is what you need. One command adds AGENTS.md, Cursor rules, Claude settings, Copilot instructions, verification, and drift workflows. Free forever.

Get Lattice Core

Frequently Asked Questions

What's the difference between Basic and Pro Planning?

Basic Planning uses a fast, single-pass AI engine, perfect for most projects. Pro Planning uses multiple AI models that debate and refine your setup, catching edge cases and producing deeper architecture analysis. Both are included at every paid tier.

How long does it take to generate a project?

Basic Planning takes 15-30 seconds. Pro Planning takes 60-90 seconds due to multi-model deliberation. After generation, you get your custom command instantly and can start coding in under 5 minutes total.

What exactly do I get with one project?

Each project gives you PROJECT_GUIDE.md, a compatible stack plan, CI/CD workflows, a custom setup command, verification commands, reusable prompt templates, and editor-specific rules for Cursor, Claude Code, GitHub Copilot, and Codex. Supported stack combinations also get scaffolded app files; unsupported pieces come with setup notes instead of silent substitutions.

Does this work with Cursor, Claude Code, GitHub Copilot, and Codex?

Yes. Project Builder generates the files each tool actually reads: .cursor/rules.md and lattice-core.mdc for Cursor, CLAUDE.md plus .claude/settings.json for Claude Code, .github/copilot-instructions.md plus .github/instructions/lattice-core.instructions.md for GitHub Copilot, and AGENTS.md plus docs/rules/codex.md for Codex.

Can I use Project Builder for existing projects?

Project Builder is designed for new projects. It always generates the planning and guardrails pack for a new build, and supported stack combinations also get scaffolded app files. If you already have a repo, use Lattice Core (free) to add guardrails instead.

What happens if I exceed my monthly quota?

You can upgrade your plan at any time to get more projects. Unused projects don't roll over, but you can always upgrade mid-month to access higher quotas immediately.

How do I get started?

Start with one-time PAYG builds (Basic or Pro), or choose a subscription if you plan to generate regularly.

Ready to Give Your AI the Right Starting Point?

Turn one product brief into a build-ready repo for Cursor, Claude Code, GitHub Copilot, or Codex and skip the 4-6 hour setup spiral.

Start with PAYG View All Plans

PAYG starts at $9 per build. Subscriptions start at $29/month.