Stop Re-Explaining Your Stack to Your AI

Every session starts the same way. You open a fresh chat, and before you can ask the real question you type the preamble: it is a Next.js 15 app, App Router, TypeScript in strict mode, Postgres through Prisma, deployed on Vercel, and it is just me, so keep the advice scaled to one person. You paste some version of that at the top of task after task. Or, on the days you are moving fast, you skip it, and the AI cheerfully assumes the pages router and class components and an enterprise team, and you spend the first three exchanges correcting assumptions instead of doing the work.

Either way you are paying a tax. Your AI has no memory of your project between sessions, so you are the context window, refilled by hand, every single time. The fix is boring and it works: write the context down once, in a place your AI can read on demand, and stop typing it ever again.

The re-explaining tax

The tax comes due in two ways and you pay one of them every time. Pay it up front and you burn minutes and tokens re-typing the same facts, which also pushes the actual task further down the prompt where it gets less attention. Skip it and you pay on the back end: the answer assumes defaults that are wrong for you, and you spend the conversation walking it back. "Actually we use Tailwind, not styled-components." "Actually this is server-side." "Actually there is no team, I do not need a migration review committee."

Neither failure is the model being dumb. Both are the model operating without the one thing it cannot infer: the specific, stable facts about your project that do not change from task to task. Those facts are exactly the kind of thing you should write down once.

Write it down once

Make a single small file that captures the context every task needs. Keep it in your project (or wherever your AI tool reads shared context) and point the AI at it instead of re-typing. Here is the shape I use:

# Operator profile

## Stack
- Next.js 15 (App Router), React 19, TypeScript (strict)
- Tailwind v4, shadcn/ui
- Postgres via Prisma; Vercel hosting
- Tests: Vitest

## Conventions
- US English, no em-dashes in user-facing copy
- Errors: throw in the domain, handle at the route boundary
- No new dependency without a one-line reason

## Business
- Solo founder. One person ships everything.
- Product: <one sentence on what it does and who it is for>

## Constraints
- Lighthouse stays green; no client JS for static content
- Keep advice scaled to one operator, not a team

## Goals (this quarter)
- <the one or two outcomes that matter right now>

That is the whole idea. It is not a framework, it is a fact sheet. The value is that it lives in one place, it is the same every time, and it is the truth, so the AI stops guessing and you stop typing.

What actually belongs in it

Be specific, and be ruthless about length, because this file gets read on every task and bloat costs you tokens and attention. A few rules that keep it useful:

• Versions, not vibes."Next.js 15 App Router," not "React." The version and the variant are where the wrong assumptions live.
• The corrections you keep repeating. If you have told the AI three times that you use Vitest, not Jest, that line belongs in the file. Your edit history is the spec.
• Who you are."Solo founder" changes the advice more than any technical fact. It is the difference between a process built for a team and one a single person can actually run.
• Not the obvious. Leave out anything the AI can read from the code in seconds. The file is for what it cannot infer, not a transcript of your package.json.

The part that makes it more than a paste

A profile is better than a pasted preamble for a reason beyond convenience: a good skill reads only the fields it needs, when it needs them. A code reviewer reads your languages and frameworks to pick the right checklist, and reads "solo founder" to decide how hard to push on process. A debugging routine reads your language to pre-load the common bug patterns. A planning routine reads your goals to check that this week's work actually advances them. The profile is a shared source of truth that each tool pulls from on demand, rather than a wall of context you prepend to everything and hope the model weights correctly.

That is the same idea as skills that talk to each other: the cooperation works because the tools share one picture of your work instead of each starting cold. A profile is the memory half of that system. Cooperation plus shared memory is what turns a pile of prompts into something that feels like it knows you.

Teach it once

This is exactly what the onboarding step does in the Senior Solo Coder Skillpack. You run one guided pass after install, it asks about your stack, your brand, your goals, and your constraints, and it writes a profile that all 31 skills read on demand, so they stop re-asking. The reviewer already knows your framework. The planner already knows your goals. You answer the questions once instead of at the top of every task forever. You do not need the pack to get the benefit, though. Write the file above today, point your AI at it, and you have stopped paying the re-explaining tax. The pack just makes the file something 31 skills read without being told.