Prompt Engineering

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.

Open in Project Context Builder

Overview

The opening of every new chat is the same three paragraphs: what the app is, the stack it runs on, the rules the team follows. Project memory ends that. This setup builds a full context profile for Helmsman, a multi-tenant SaaS dashboard — the overview, the stack (React, TypeScript, Node, PostgreSQL, Prisma), the team conventions, and a glossary — then the engine adds the conventions and never-assume rules the stack implies. Paste it once into a Claude Project (or any tool's persistent instructions) and the AI starts every chat already knowing the project.

How to use this resource

Describe the project once

Name, overview, mode, and stack — the facts you keep retyping into new chats.
Let the engine fill the rest

The stack you typed becomes naming rules, conventions, and never-assume lines automatically.
Paste it where it persists

Drop the profile into your tool's project instructions; every new chat starts informed.

Why This Works

The profile is loaded once and applies to every chat — no more re-explaining the basics
Stack detection turns "React, TypeScript, Postgres" into the conventions those tools imply
The never-assume section stops the model guessing the things it always gets wrong

Best for

Teams tired of re-explaining the same project
Multi-tenant SaaS codebases
Anyone setting up a Claude Project or custom instructions

Not for

A one-off task persona — that's the System Prompt Generator
Carrying an in-progress task to a new chat — that's the Context Handoff Builder

FAQ

How does typing my stack turn into the 'Team Conventions' and 'Never Assume' lines?

The builder infers them from the tools you name. Listing Prisma, TypeScript, and Tailwind auto-generates matching rules — 'No any; prefer unknown with narrowing' under Team Conventions and 'Do not hand-write SQL when a Prisma query exists' under Never Assume. The profile carries those conventions; the assistant you paste it into applies them, and you edit any line that doesn't fit.

The 'Profile completeness: 100/100' line at the bottom — is that checking my facts are correct?

It only rates how much of the profile you filled in — overview, stack, conventions, glossary, and rules — not whether the facts are true. When something is unknown, the builder leaves a bracketed gap instead of inventing it, so a lower score flags real missing info to supply. Treat it as a browser-side coverage checklist, not verification of your project.

Why does the profile split 'Always Remember' from 'Never Assume' instead of one rules list?

They target different failure modes. 'Always Remember' holds standing facts the model should carry — 'All timestamps are stored in UTC', 'Production data is never used in tests'. 'Never Assume' blocks specific wrong guesses — 'Do not assume the schema', 'Do not assume a request is for a single global dataset'. Splitting them keeps positive facts and guardrails distinct so the assistant treats each correctly.

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: Helmsman

> Paste this into your Claude Project: open the project, Edit, and add it to the project instructions.

## Project Overview
Helmsman is a multi-tenant SaaS dashboard that lets agencies manage client ad campaigns from one place. Each agency is a tenant with isolated data and per-seat billing.

## Core Facts
- Project type: SaaS Product
- Primary stack: React, Tailwind CSS, Express, Node.js, PostgreSQL, Prisma
- This is a multi-tenant SaaS product — tenant data isolation and uptime are non-negotiable.

## Tech Stack
- React
- Tailwind CSS
- Express
- Node.js
- PostgreSQL
- Prisma
- TypeScript

## Team Conventions
- Every API route is covered by an integration test.
- Feature flags gate anything not GA yet.
- Money is stored in integer cents, never floats.
- Function components with hooks only — no class components; keep components pure and side effects in effects. (React)
- Style with Tailwind utility classes; reach for custom CSS only when no utility fits. (Tailwind CSS)
- Keep route handlers thin; put logic in services and use middleware for cross-cutting concerns. (Express)
- Prefer async/await over callbacks; never block the event loop with sync I/O in request paths. (Node.js)
- Change the schema through `schema.prisma` and migrations; use the generated client, not raw SQL, unless necessary. (Prisma)
- No `any` — prefer `unknown` with narrowing; keep `strict` mode on and types honest. (TypeScript)

## Naming Rules
- Database: snake_case for tables and columns; plural table names. (PostgreSQL)
- camelCase for variables and functions, PascalCase for types and components. (TypeScript)

## Architecture Principles
- Every data access is scoped to a tenant — never return one tenant's data to another.
- Treat billing, auth, and data-isolation code as critical paths; changes there need extra scrutiny.
- Design for graceful degradation — a failing feature must not take the whole product down.

## Glossary
- **Tenant** — a paying agency account; the top-level data boundary.
- **Seat** — one billable user within a tenant.
- **MRR** _(abbreviation)_ — monthly recurring revenue.
- **Workspace** — a client account owned by a tenant.

## Always Remember
- Production data is never used in development or tests.
- All timestamps are stored in UTC.
- This profile is the source of truth for project facts — prefer it over general assumptions.

## Never Assume
- Do not assume a feature is generally available — check the feature flag.
- Do not assume a component is class-based — the codebase uses function components and hooks.
- Do not add a global stylesheet or CSS-in-JS — styling is utility-first with Tailwind.
- Do not assume the schema — reference the migrations or schema file before writing a query.
- Do not hand-write SQL when a Prisma query exists — and do not edit generated client code.
- Do not assume a value's type — check the type definition before changing a signature.
- Do not assume a request is for a single global dataset — it is tenant-scoped unless stated otherwise.
- Do not assume the current user has access to a resource — authorization is checked explicitly.
- When a fact is missing from this profile, ask — do not invent it.

## AI Usage Notes
- In Claude, project instructions apply to every chat inside the project — paste this once and start new chats freely.
- 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

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

Resource

Set AI Team Conventions Everyone Shares

When every teammate explains the project differently, AI gets a different story each time. Shared team conventions give it one consistent account.

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

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