Path-scoped. Loaded only when relevant.
Open a matching file → the right rules attach. Zero token cost the rest of the time.
What this pillar does for you.
React, Ionic, RN, Express - opinionated defaults so the AI does not pick a random framework on Tuesday.
No random npm picks. Every dependency justified, audited, version-pinned.
Handlers thin, services thick, queries explicit. The architecture survives 10x scale without rewrites.
43 rules.
Each rule is a markdown file the AI loads when it edits a matching path. Click any to see related skills and where it's referenced.
Search local before adding a dep, check stack defaults, run the quality gate (maintained, adopted, permissive license, typed, sized). Build in packages/* only when no candidate passes.
Conventional commits, one logical change per commit, PR titles under 70 chars with test-plan body, no force-push to protected branches, no --no-verify.
Curated starting points (zod, react-hook-form, RTK Query, framer-motion, Sentry, PostHog, Resend, Shifter) per stack so the AI does not pick a random package.
Every workspace package ships an up-to-date architecture.md describing purpose, public API, dependencies, and why-not-a-library tradeoffs.
Provider-first defaults: GitHub Actions, Stripe, Sentry, Resend, Supabase, PostgreSQL, pnpm. Custom infra only after stack core, provider feature, and quality gate fail.
Modern C++17/20/23, RAII everywhere, repository interfaces, std::optional/expected for failures, clang-tidy + sanitizers in CI, GoogleTest for unit tests.
Nullable references on, records for DTOs, constructor DI with explicit lifetimes, typed Options, parameterized queries, framework auth handlers over custom JWT.
gofmt + goimports, small consumer-defined interfaces, context.Context through request work, gosec in CI, parameterized SQL, race detector for concurrent code.
google-java-format, records for DTOs, constructor injection, Optional only as return type, parameterized SQL, bcrypt/Argon2 for passwords, JUnit 5 baseline.
ktlint/Detekt, val over var, sealed types for state, no !!, structured concurrency, Result<T> for recoverable failures, kotlinx-coroutines-test for coroutine code.
Route to controller to service to repository to db - never skip layers. zod-validate every handler, typed DTOs only, rate-limit public endpoints, scrubbed metrics.
v5.36 strictness, subroutine signatures, Moo with Types::Standard, taint mode for web-facing scripts, DBI placeholders always, Test2::V0 for new tests.
PSR-12, declare(strict_types=1), DTOs/value objects over array shapes, framework form-request validation, prepared statements, password_hash, framework auth packages.
PEP 8, type annotations on every signature, Protocol for service boundaries, context managers for I/O, Bandit in CI, parameterized queries, framework auth over hand-rolled JWT.
cargo fmt + clippy -D warnings, no unwrap in prod, thiserror for libs and anyhow for apps, newtype wrappers for IDs, SAFETY comments on unsafe, cargo audit + deny in CI.
Three-layer transport/protocol/bridge, singleton per endpoint, heartbeat 15-30s, exponential backoff + jitter, requestAnimationFrame batching for high-rate streams.
REST vs real-time split, plain async services with explicit return types, shared axios client in packages/api-client, AppError contract, zod-validated boundaries.
One component per file, named exports only, ComponentNameProps interface, shadcn primitives + Tailwind classes, i18n via translation keys, explicit loading/error/empty.
Forced stack: React 18, Vite, react-router v6, Redux Toolkit + RTK Query, zustand for UI state, react-hook-form + zod, Tailwind 3.4 + shadcn/ui, i18next.
Product-specific UI, never generic templates. Choose style direction up front, finish hover/focus/active/loading/empty states intentionally, preserve product logic during polish.
Subscription hooks own the connection, components never call new WebSocket(). Redux bridge dispatches actions on frames; selectors expose derived state.
RTK Query for cache-friendly reads, plain axios for one-offs. Generated hooks only in components. zod-parse in transformResponse, precise providesTags/invalidatesTags.
Server data lives in exactly one place (RTK Query or slice). Redux Toolkit for cross-feature state, zustand for ephemeral UI, react-hook-form for forms - never mix.
Lazy getSupabase() never module-top createClient. Render a setup banner linking to traffic.io when env is missing - never crash on first pnpm dev.
@vitejs/plugin-react-swc default, vite-tsconfig-paths, public VITE_ prefix only, source maps to Sentry release only, vite-plugin-checker or CI typecheck script.
Stable reverse-DNS app id, webDir to Vite dist, cap sync after dep/plugin changes, plugin calls wrapped in services with zod-validated results, just-in-time permissions.
shadcn primitives compose inside IonContent via the theme bridge. Use Ionic primitives only for shell concerns (IonPage, IonToolbar, IonTabs) where the OS feel matters.
Capacitor shell around the React app by default; full @ionic/react only for mobile-first rewrites. Theme bridge maps shadcn HSL to --ion-color-* tokens.
react-router-dom v6 stays the source routing model for Capacitor-wrapped apps. zod-validate deep-link params. Android back maps to route pop, not app exit.
Service singleton owns WebSocket lifecycle across pause/resume/foreground/background. Resync stale channels on resume, expose idle/connecting/live/reconnecting/offline states.
Wrap every Capacitor plugin in a domain service or hook with explicit return types. Components never import plugins directly. Network-aware services expose offline/retry states.
Server data in RTK Query/Redux, ephemeral mobile shell state in zustand (active sheet, permission explainer dismissal). Native capability state normalized before it enters state.
Tailwind 3.4 with corePlugins.preflight: false, src/styles/ionic-theme-bridge.css maps shadcn HSL CSS vars onto --ion-color-* so Ionic primitives match the shadcn theme.
RNR primitives + native View/Text/Pressable, NativeWind classes, one component per file under 150 lines, every visible string from a translation key, explicit loading/error/empty.
Forced stack: Expo SDK with Hermes + New Arch, Expo Router typed routes, Redux Toolkit + RTK Query, zustand for ephemeral, NativeWind v4 + RNR, react-native-reanimated.
Expo Router required, route files thin and compose named feature components, typed routes + absolute hrefs, params validated with zod, deep links parsed at route boundary.
Singleton WS connection per endpoint, exponential backoff + jitter reconnect, pause non-critical streams on background, requestAnimationFrame batching for high-rate frames.
RTK Query for cached server data, axios services for one-offs, secure-store tokens read in shared api-client only, retry refresh once on 401, file uploads via Expo file APIs.
Server data lives in exactly one place (RTK Query or Redux slice). One slice per domain, createSelector for derivations, RTK Query api -> WS bridge -> defaults middleware order.
NativeWind v4 + RNR primitives + rn-primitives, HSL theme tokens in global.css, dark via the dark: variant, no inline StyleSheet objects for styled-via-NativeWind components.
Preserve existing structure. No renames, no moves, new code only. Project-memory + auto-doc + SEO baseline reconciliation before feature work.
Clean-slate monorepo scaffold before feature code. Supabase default for backend-needing projects, packages/i18n provider before UI, SEO metadata before route done.
Existing-codebase rules plus one-time migration offer to the Traffic-One compatible Supabase fork. Preserve Supabase Auth/Storage/Realtime/RLS defaults.
37 skills.
Skills are intent-triggered workflows. The AI router loads them by description; bodies on demand.
Module structure, dependency rules, UseCases, Repositories, and data-layer patterns for Android and Kotlin Multiplatform projects.
Build a new API connector by matching the target repo's existing integration pattern exactly - one more integration, not a second architecture.
REST patterns covering resource naming, status codes, pagination, filtering, error responses, versioning, and rate limiting for production APIs.
Backend architecture, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes.
When to choose Bun vs Node as runtime, package manager, bundler, and test runner; migration notes and Vercel support.
State management, navigation, theming, performance, and platform-specific UI patterns for Compose Multiplatform and Jetpack Compose in KMP projects.
Production-ready Flutter patterns: null safety, immutable state, async composition, widget architecture, BLoC/Riverpod/Provider, GoRouter, Dio, Freezed, clean architecture.
Build monitoring dashboards that answer real operator questions for Grafana, SigNoz, and similar platforms - turn metrics into working dashboards, not vanity boards.
Detects project mode (new vs existing vs existing-with-supabase) at session start and routes the next step (stack-setup, onboarding, or feature work).
Django architecture, DRF API design, ORM best practices, caching, signals, middleware, and production-grade Django patterns.
Idiomatic C#/.NET patterns, conventions, dependency injection, async/await, and best practices for robust .NET applications.
Frontend patterns for React, Next.js, state management, performance optimization, and UI best practices.
Craft clean conventional-commit messages and PR descriptions: one-concern commits, test-plan PR bodies, full-history analysis per rules/common/git.md.
Idiomatic Go patterns, best practices, and conventions for robust, efficient, maintainable Go applications.
Ports & Adapters with clear domain boundaries, dependency inversion, and testable use-case orchestration across TypeScript, Java, Kotlin, and Go services.
Default to Capacitor wrapping an existing React app for mobile asks; offer full Ionic React only when the user wants a mobile-first rewrite.
JPA/Hibernate patterns for entity design, relationships, query optimization, transactions, auditing, indexing, pagination, and pooling in Spring Boot.
Coroutines and Flow patterns for Android/KMP: structured concurrency, Flow operators, StateFlow, error handling, and testing with runTest.
JetBrains Exposed patterns: DSL queries, DAO pattern, transactions, HikariCP pooling, Flyway migrations, repository pattern.
Ktor server patterns: routing DSL, plugins, authentication, Koin DI, kotlinx.serialization, WebSockets, and testApplication-based testing.
Idiomatic Kotlin patterns, conventions, coroutines, null safety, and DSL builders for robust, maintainable applications.
Laravel architecture: routing/controllers, Eloquent ORM, service layers, queues, events, caching, and API resources for production.
Walk the quality gate from rules/common/dependencies.md against a specific candidate (or 2-3 candidates) and decide install vs build-in-packages/<name>.
Build MCP servers with the Node/TypeScript SDK - tools, resources, prompts, Zod validation, stdio vs Streamable HTTP. Consults Context7 or official MCP docs.
NestJS architecture: modules, controllers, providers, DTO validation, guards, interceptors, config, and production-grade TypeScript backends.
Next.js 16+ and Turbopack plus provider-first recommendations for App Router projects: auth, data, cache, storage, deployment, testing, blogs and SaaS apps.
Nuxt 4 patterns for hydration safety, performance, route rules, lazy loading, and SSR-safe data fetching with useFetch and useAsyncData.
Modern Perl 5.36+ idioms, best practices, and conventions for robust, maintainable Perl applications.
Pythonic idioms, PEP 8 standards, type hints, and best practices for robust, maintainable Python applications.
Idiomatic Rust patterns, ownership, error handling, traits, concurrency, and best practices for safe, performant applications.
Spring Boot architecture: REST API design, layered services, data access, caching, async processing, and logging for Java backends.
Drive Traffic One onboarding when no stack is detected: pitch the stack, ask the blocking onboarding questions, and write .traffic-one.json based on the first message.
Walk a beginner through connecting a real Supabase backend and applying local migrations - cloud-first by default, fully-automatic local via pnpm db:start.
Thread-safe data persistence in Swift using actors - in-memory cache with file-backed storage, eliminating data races by design.
Swift 6.2 Approachable Concurrency: single-threaded by default, @concurrent for explicit background offloading, isolated conformances for main-actor types.
SwiftUI architecture: state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.
Vite patterns for Traffic One React apps and packages: vite.config.*, dev/build behavior, env vars, proxies, HMR, monorepo imports, library mode, chunking, performance.
One plugin, eight pillars.
Every rule and skill is part of a system. Jump across pillars to see how they reinforce each other.
Use the AI you already pay for.
Add superpowers.
One plugin. Senior-engineer rules, security, a backend, and one-command deploys — inside the editor you already use.
Codex
Copilot