Engineering

Coding Conventions for AI

Tell AI your code style once. List the stack and the engine returns the naming rules and conventions it implies — plus your own house rules carried verbatim.

Open in Project Context Builder

Overview

AI writes plausible code that quietly ignores your conventions — class components in a hooks codebase, hard-coded colors in a tokenized design system. This setup captures the conventions for Atlas UI, a shared React component library, where a breaking change ripples across every product team. You list the house rules (additive props, tokens not hard-coded values); the engine adds the React, TypeScript, and Vitest conventions and naming rules automatically. The AI stops guessing your style and starts following it.

How to use this resource

List the stack

React, TypeScript, Vitest — each maps to known naming and convention rules.
Add your house rules

Additive props, tokens over hard-coded values; these travel verbatim.
Hand the AI the conventions

It writes code that matches the codebase instead of generic defaults.

Why This Works

Stack detection means you list "TypeScript" and get "no any, strict mode on" for free
Your own conventions are carried word-for-word, never paraphrased
A design-system library is exactly where convention drift causes the most damage

Best for

Shared libraries and design systems
Teams with a documented style guide
Codebases AI keeps writing against the grain of

Not for

Reviewing a specific diff against the rules — use the Code Review Prompt Generator
Defining a reviewer persona — use the System Prompt Generator

FAQ

How does listing 'TypeScript' produce naming rules I never typed?

Each stack name maps to its known conventions, so entering TypeScript pulls in 'No any — prefer unknown with narrowing; keep strict mode on' and the naming rule 'camelCase for variables and functions, PascalCase for types and components,' while React adds the function-components-with-hooks rule. The builder writes these into the profile text; you still paste it into your assistant, which does the actual coding.

Where do I put the generated Atlas UI profile so Cursor actually loads it?

The template's own note says to save it at your repo root as '.cursorrules' (or '.cursor/rules/project.mdc') so Cursor loads it for every request, which means the Atlas UI conventions travel with the code and every teammate inherits the same context. For ChatGPT or Claude, paste it into custom instructions or a project instead. It's project knowledge you re-update, not persistent memory.

How do my house rules like 'additive props' stay separate from the auto-added stack rules?

They all sit under one Team Conventions section, so what tells them apart is the source tag. Your typed rules appear untagged and verbatim — 'Props are additive — never rename or remove a prop without a major version' and 'Design tokens come from the theme, never hard-coded values' — while stack-inferred rules carry a marker like '(React)' or '(Vitest)'. The builder never paraphrases the ones you wrote.

Customize This Resource

Opens this project in Project Context Builder. Build to get the full context profile — then adjust the mode, stack, glossary, and output target.

Open in Project Context Builder

Prompt Template

Copy it as-is, or use Open in Project Context Builder to load it pre-filled and customize it with your own context.

# Project Context: Atlas UI

> Save this at your repo root as `.cursorrules` (or `.cursor/rules/project.mdc`) so Cursor loads it for every request.

## Project Overview
Atlas UI is a shared React component library used by every product team in the company. Changes ripple across many apps, so backward compatibility is critical.

## Core Facts
- Project type: Software Project
- Primary stack: React, TypeScript, Vitest, Storybook
- This is a software codebase — correctness, readability, and maintainability come before cleverness.

## Tech Stack
- React
- TypeScript
- Vitest
- Storybook

## Team Conventions
- Every component ships with stories and accessibility tests.
- Props are additive — never rename or remove a prop without a major version.
- Design tokens come from the theme, never hard-coded values.
- Function components with hooks only — no class components; keep components pure and side effects in effects. (React)
- No `any` — prefer `unknown` with narrowing; keep `strict` mode on and types honest. (TypeScript)
- Keep tests fast and isolated; use fake timers for time-dependent code. (Vitest)

## Naming Rules
- camelCase for variables and functions, PascalCase for types and components. (TypeScript)

## Architecture Principles
- Keep modules focused — a file or function should do one thing well.
- Prefer clarity over abstraction; introduce indirection only when duplication has actually appeared.
- Changes should come with the test that proves them.

## Glossary
- **Token** — a named design value (color, spacing, radius) from the theme.
- **Variant** — a named visual style of a component.
- **Slot** — a named insertion point for consumer content.

## Always Remember
- This library is consumed by many apps — a breaking change is a company-wide event.
- This profile is the source of truth for project facts — prefer it over general assumptions.

## Never Assume
- Do not hard-code colors or spacing — read them from design tokens.
- Do not assume a component is class-based — the codebase uses function components and hooks.
- Do not assume a value's type — check the type definition before changing a signature.
- Do not assume how a module is used elsewhere — check the call sites before changing a signature.
- When a fact is missing from this profile, ask — do not invent it.

## AI Usage Notes
- Cursor reads project rules from the repo, so this travels with the code and every teammate gets the same context.
- This profile is project KNOWLEDGE, not behavior — for a task persona (role, tone, escalation rules), build a System Prompt in the System Prompt Generator.
- It is durable project identity, not work state — to continue an in-progress task in a new chat, use the Context Handoff Builder.
- Profile completeness: 100/100 (Complete) — bracketed gaps, if any, mark missing info that was never invented.

More resources from Project Context Builder

Resource

Build Project Memory for AI

Stop re-explaining your project in every new chat. Capture it once as a context profile the AI keeps across every conversation — stack-inferred conventions and all.

Prompt Engineering

Resource

Create an AI Project Profile

A reusable profile that tells AI everything constant about your project — type, stack, conventions, glossary, architecture principles, and the rules it must never guess.

Prompt Engineering

Resource

AI Onboarding Context for an Existing Codebase

Onboard AI to a codebase the way you'd onboard a new hire: what it is, how it's built, the rules that aren't written down, and the things never to assume.

Engineering

Resources that pair well

Resource

AI Session Handoff — Shift Change for Working Sessions

End a working session like a shift change, not an abandonment: state captured, decisions logged, next step named — ready for the next session to pick up.

Prompt Engineering

Resource

Bug Triage Assistant

Convert scattered bug notes, Slack messages, or user complaints into structured engineering tasks with reproduction steps, severity, and root cause hypothesis.

Engineering

Resource

Convert a Conversation to a Prompt — the Full Anatomy

What a converged conversation contains: a rejected voice, an accepted framing, a hard constraint, a format decision, and a final-version moment — each mapped to its prompt section.

Prompt Engineering

Related tools

Tool

Project Context Builder

Define what AI should permanently know about your project — stack conventions, glossary, and never-assume rules in a profile you paste once.

Context Tools

Guides for this resource

Guide

How to Configure AI to Follow Your Codebase's Conventions

The code compiles, the tests pass, and it doesn't look like anything else in the repo. "Follow our conventions" is a wish: yours aren't written down, they're spread across nine hundred files that disagree. Here's how to extract the real rules and test them.

Software Development with AI

Tip: Save time by exploring related resources and tools that integrate with this resource.