Prompt Engineering

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.

Open in Project Context Builder

Overview

A project profile is the document you wish every new AI chat already had. This setup builds one for Ledger API, a public REST platform where hundreds of integrations depend on stable response shapes. The API Platform mode contributes contract-first architecture principles; the stack (C#, ASP.NET Core, EF Core, PostgreSQL) contributes its naming and convention rules; your glossary defines postings and journals. The result is a single profile that captures the whole project identity — paste it once and reuse it everywhere.

How to use this resource

Pick the project mode

API Platform, SaaS, Internal Tool — the mode sets sensible architecture principles.
Add the facts only you know

Overview, conventions, glossary; the engine derives the stack-driven parts.
Reuse the profile everywhere

One document covers every conversation about the project.

Why This Works

Mode-driven architecture principles match how an API platform actually has to behave
Every section the AI needs is in one place, structured and skimmable
Completeness scoring shows exactly what the profile is still missing

Best for

Public APIs with external consumers
Projects that need a single source-of-truth doc
First-time profile creators

Not for

Describing how the AI should sound or behave — use the System Prompt Generator
A snapshot of current work state — use the Context Handoff Builder

FAQ

How does a project profile stop AI from guessing facts about my codebase?

It hands the model the constants up front and forbids invention. The Never Assume section bars removing or repurposing a response field, assuming the schema instead of checking migrations, and inventing any fact missing from the profile — where a fact is absent, the AI must ask. Always Remember also names it the source of truth for project facts over general assumptions.

When should I use a project profile instead of a system prompt?

When you're capturing knowledge, not behavior. The AI Usage Notes draw the line: this profile is project KNOWLEDGE — stack, conventions, glossary — while a task persona with role, tone, and escalation rules belongs in the System Prompt Generator. For an in-progress task continued in a new chat rather than durable identity, it points to the Context Handoff Builder.

What does the API Platform mode actually add to the profile?

Contract-first architecture principles specific to a public interface. Choosing API Platform contributes rules like breaking changes require a version bump never a silent edit, validate input at the boundary with documented error shapes, and keep responses backward-compatible by adding fields, not repurposing them. The project-context-builder also derives stack-driven parts from C#/ASP.NET Core/EF Core/PostgreSQL, so you only add the facts only you know.

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: Ledger API

> Save this at `.github/copilot-instructions.md` in your repo so Copilot Chat picks it up automatically.

## Project Overview
Ledger API is a public REST API that lets fintech partners record and query double-entry transactions. Hundreds of external integrations depend on its response shapes.

## Core Facts
- Project type: API Platform
- Primary stack: ASP.NET Core, PostgreSQL, Entity Framework Core, xUnit, C#
- This is an API platform — the public interface is a contract that consumers depend on.

## Tech Stack
- ASP.NET Core
- PostgreSQL
- Entity Framework Core
- xUnit
- C#

## Team Conventions
- Every endpoint is versioned under /v1, /v2; new fields are additive only.
- Errors return the standard problem-details shape.
- Idempotency keys are required on all write endpoints.
- Use dependency injection via the built-in container and async controllers; follow the existing layering. (ASP.NET Core)
- Use migrations for schema changes and async LINQ queries; watch for N+1 with eager/explicit loading. (Entity Framework Core)
- Use [Theory]/[InlineData] for cases; one logical assertion per test where practical. (xUnit)

## Naming Rules
- Database: snake_case for tables and columns; plural table names. (PostgreSQL)

## Architecture Principles
- The public API is a contract: breaking changes require a version bump, never a silent edit.
- Validate input at the boundary and return predictable, documented error shapes.
- Keep responses backward-compatible; add fields, don't repurpose or remove them.

## Glossary
- **Posting** — a single debit or credit line in a transaction.
- **Journal** — a balanced set of postings.
- **Idempotency key** — a client-supplied token that makes a write safe to retry.

## Always Remember
- A transaction must always balance — total debits equal total credits.
- This profile is the source of truth for project facts — prefer it over general assumptions.

## Never Assume
- Do not remove or repurpose a response field — consumers depend on it.
- Do not assume the schema — reference the migrations or schema file before writing a query.
- Do not change a public endpoint's shape without treating it as a breaking change.
- Do not assume a consumer tolerates extra latency or new required fields — they are part of the contract.
- When a fact is missing from this profile, ask — do not invent it.

## AI Usage Notes
- Copilot reads repo instructions for everyone working in the codebase — commit this file so the context is shared.
- 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

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.