Coherent by default
UI, data, auth, errors, observability, and product state follow one shared set of conventions.
Open-source frontend foundation
The frontend decisions are already made.
Atlas generates a production-ready Next.js workspace with architecture, authentication, API integration, configuration, testing, and CI already in place. Every file is source in your repository, yours to read, change, and ship.
pnpm dlx @blitzcraftlabs/atlas init my-appAtlas product properties
Production included
Accessibility, logging, analytics, testing, and CI are part of the foundation from day one, not work deferred until launch.
Fully yours
Fork the codebase, remove the examples, replace integrations, and evolve the architecture with your product.
02Quick start
Install Atlas.
Start with the product.
The Atlas CLI creates a complete Next.js workspace in a directory you own. Three steps from an empty folder to a running app.
Prerequisites
- Node.js
>=22 - pnpm
>=10
New Atlas project
Create
Generate a source-owned Atlas workspace in my-app.
pnpm dlx @blitzcraftlabs/atlas init my-appInstall
Move into the project and install dependencies.
cd my-apppnpm installRun
Start the dev server, then open http://localhost:3000.
pnpm dev
Contributing to Atlas itself? Clone the repository instead.
These commands set up the Atlas source repository for platform development. You don't need them to build an app with Atlas.
git clone https://github.com/blitzcraftlabs/atlas.git
cd atlas
corepack enable
pnpm install
cp apps/web/.env.example apps/web/.env.local
pnpm --filter @atlas/web dev03Everything included
Make the recurring
decisions once.
Atlas brings the architecture, infrastructure, tooling, and production conventions together as one foundation, so teams don't have to assemble them again for every product.
Application architecture
feature modules · ownership boundaries
Atlas is not just a bundle of libraries. It encodes a coherent frontend architecture: thin Next.js App Router routes, feature modules that own domain logic with no cross-feature imports, shared infrastructure in lib/, reusable primitives in packages/ui, and shared tooling in packages/.
- Thin App Router routes in apps/web/src/app/
- Feature modules with no cross-feature imports
- Shared infrastructure in apps/web/src/lib/
- Reusable primitives in packages/ui/
- Shared ESLint & TypeScript config in packages/
- Turborepo + pnpm workspaces
atlas/
├── apps/web/src/
│ ├── app/ # Routes & layouts — thin pages only
│ ├── features/ # Domain modules — no cross-feature imports
│ ├── lib/ # API, auth, telemetry, shared infra
│ └── schemas/ # Zod validation
├── packages/
│ ├── ui/ # Reusable primitives (@atlas/ui)
│ └── config/ # ESLint, TypeScript, shared tooling
├── openapi/ # API contract
├── turbo.json # Turborepo task pipelines
├── pnpm-workspace.yaml # pnpm workspaces
└── AGENTS.md # Ownership boundaries04Built with Atlas
One foundation.
Different products.
Atlas has been used across knowledge products, developer infrastructure, and production applications without forcing them into the same product shape.
05End-to-end types
One contract. One path to the interface.
From the source contract to the generated client, feature module, and product UI, Atlas keeps the path typed end to end.
Verified by
- Typecheck
- Tests
- Production build
OpenAPI
Source contract
openapi/openapi.jsonGenerated client
SDK + TypeScript
lib/api/contractsFeature module
Domain boundary
features/usersProduct UI
React interface
apps/web
Atlas foundation
06Agent context
Any agent.
Same architecture.
Change your agent, not your engineering standards.
Architecture rules, feature boundaries, reference implementations, and verification live in the repository, so every coding agent works from the same context.
Agent context transcript
Interactive transcript showing that any coding agent loads the same Atlas repository context. Only the agent flag in the command changes.
context --agent cursor
Reading
AGENTS.mdRepository architecture and conventions loaded
Locating feature boundary
apps/
web/ src/ features/ users Finding reference implementation
apps/
web/ src/ features/ examples Applying repository conventions
Thin routes · feature ownership · no cross-feature imports
Verifying implementation
validate:env · lint · typecheck · test · build
Architecture preserved
07No black boxes
Inspect the decisions,
then make them yours.
Atlas is source code, documented decisions, and explicit conventions, not a runtime you rent. Inspect how it works, keep what earns its place, and change what doesn't.
Inspect
Change
- KEEP
packages/uiShared primitives - REPLACEAuthentication providerBring your own auth integration
- EXTENDFeature managementAttach your own monitoring or flagging stack
- CHANGE
.github/workflowsVercel, AWS, self-hosted, or your preferred delivery path - EDIT
AGENTS.mdYour team's conventions
08Built from practice
I built Atlas from the frontend problems I kept solving.
Daniel Mark
Frontend engineer & consultant
I'm Daniel Mark, a frontend engineer and consultant. Atlas is the reference implementation behind the way I build product frontends: clear ownership boundaries, typed contracts, reusable UI, production infrastructure, and engineering conventions that stay consistent as the product grows.
If your team is starting a new frontend, outgrowing an inconsistent codebase, or trying to make AI-assisted development safer, I can help apply the same principles to your product.
Starting from scratch
Design and implement a frontend foundation for a new product with clear boundaries, shared infrastructure, typed contracts, reusable UI, testing, and delivery conventions from day one.
Architecture · Next.js · Design systems · CI
Your frontend is getting harder to change
Audit the current architecture, identify where ownership and infrastructure have drifted, and migrate the codebase toward clearer boundaries without requiring a full rewrite.
Architecture audits · Migrations · Platform cleanup
AI is increasing output faster than consistency
Encode repository conventions, reference implementations, ownership rules, and verification gates so engineers and coding agents can move quickly without bypassing the architecture.
Agent context · Repository rules · Quality gates
09FAQ
Questions teams ask
before they adopt Atlas.
Atlas is opinionated by design. These are the questions that usually matter before making it part of a codebase.
10Work with me
Bring this approach
to your frontend.
Whether you're starting a product, cleaning up an existing frontend, or trying to make agent-written code more predictable, I can help design and implement the foundation with your team.