Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/xxyoudeadpunkxx/gpt-pf-chat-gpt-project-forge/llms.txt

Use this file to discover all available pages before exploring further.

Project Forge is a preparation system, not a fully autonomous one. The canonical files define how the system works, but every preparation session still depends on a human operator who decides what to expose, what to trust, when to open a target project, and when to stop. This guide explains how to run that operating rhythm well. It is not a substitute for the canonicals, and it cannot override them. Use it to operate the system, not to rewrite it.
Project Forge does not remove operator responsibility. It makes it more visible.

​
Where Authority Really Lives

When you need a definitive answer about how Project Forge works, go to the canonicals — in this order:
  1. 00_SCOPE.md — closes the frame: what the system is, what it is for, what its target is
  2. 01_RULES.md — closes the criteria: authority order, classification, residence, validation, readiness
  3. 03_ARTIFACTS.md — closes the artifact grammar: what artifact classes exist and what each one is for
  4. 02_PROTOCOL.md — closes the working procedure: how criteria are applied, how states are assigned
This is both the canonical read order and the practical order for rebuilding the system in a fresh session. Start with frame. Do not start from 02_PROTOCOL.md alone. Without frame, rules, and artifact grammar, procedure can be misread as permission.
This operator guide is not canonical authority. Do not use it to override 00_SCOPE.md, 01_RULES.md, 03_ARTIFACTS.md, or 02_PROTOCOL.md. If this guide appears to conflict with any canonical file, the canonical wins.

​
What Project Forge Is and Is Not

Project Forge is a preparation system for opening target projects in ChatGPT. Its job is to prepare a target project so it can start from explicit structure — a real opening package — instead of reconstructing the case from chat history and accumulated conversational context. Its job is not to run the target project. If the target project can start cleanly without rebuilding hidden context, Project Forge is doing its job. Project Forge is not:
  • a live project
  • a case archive or notebook
  • a raw dump of sources
  • a replacement for memory
  • a place to keep transient state inside the canonical core
If case state starts living in the canonicals, the system is being used incorrectly.

​
Operator Responsibilities

Some decisions cannot be delegated to the AI. The following are decisions only the operator makes:
  • Deciding session type — whether the session is a fresh case, a re-entry into an existing case, or a smoke test of the system itself
  • Deciding what materials to expose — which sources, artifacts, and files enter the session
  • Deciding what is official enough to count as basis — source trust and validation authority belong to the operator, not the model
  • Deciding when to open the target project — readiness is a gate, and whether the gate is truly satisfied is an operator call
  • Deciding when a session is contaminated and should be reset — when trust in the current context collapses, the operator decides whether to repair or restart

What the AI Is Useful For

Reading the canonicals correctly. Classifying information against the rules. Pointing out missing or weak pieces. Building authorized artifacts from the templates. Holding the protocol line when momentum would bypass it.

What Remains Operator Judgment

Real authority over sources. Whether the setup is actually clean. Whether a target project should be opened now or later. Whether something is official enough to count as basis. Whether a session has drifted past the point of trust.

​
The Smallest Correct Way to Start a Case

Start smaller than you think. Each of these steps has real closure criteria — do not move forward until the current step is genuinely complete.
1

Close the Object

Be able to state in plain language: what target project is being prepared, what opening decision is being made now, and what outcome must exist at opening. If you cannot say that clearly, you are not ready for artifact creation.
2

Close the Target

Close three things: objective, scope in, and scope out. If any of those three are unstable, the honest state is usually NOT_READY. The web compiler provides a guided surface for filling these sections.
3

Close the Output Set

Be able to name what the target project must receive. Decide whether a target brief is needed, whether an initial SSOT is needed, whether handoff is needed, and whether a transfer artifact is needed.
4

Classify the Information

For each meaningful information unit, decide whether it is PERSISTENT or VOLATILE — then decide residence. Never reverse that order. Assigning residence before stability is closed creates fake structure.
5

Assign Residence

For each classified unit, choose one of: CANONICAL, EXTERNAL_ARTIFACT, RUNTIME_OPERATOR_INPUT, or DO_NOT_STORE. In normal use, most case-specific material belongs in EXTERNAL_ARTIFACT. That is a feature, not a failure.
6

Validate Sources

Before something becomes official basis, close four things: authority, role, relevance, and freshness (when time-sensitive). “It sounds plausible” or “we discussed it earlier” does not count as validation.
7

Apply Readiness

Check documentary readiness (is the package closed enough on paper?) and measurable readiness when the domain requires it. Then close the honest state: READY, NOT_READY, BLOCKED, or CONFLICT. Do not smooth over NOT_READY with optimism.
8

Emit Only Authorized Artifacts

Do not emit artifacts because they “might be useful.” Emit them because the system says they are the correct surface for the current state. Every artifact emitted should answer a real closure need.

​
What to Give the AI at Session Start

A good startup package is small and deliberate:
  • AI_START.md — bootstrap routing for the AI; tells it what to read, what not to assume, and how to treat memory
  • The 4 canonicals (00_SCOPE.md, 01_RULES.md, 03_ARTIFACTS.md, 02_PROTOCOL.md)
  • Only the artifacts that actually exist
  • Only the source material you intend to expose
Do not give:
  • Old chat transcripts as if they were authoritative
  • Mixed notes that have not been classified
  • Every available source “just in case” — volume creates noise before it creates clarity
  • Hidden assumptions the AI will treat as basis
If you want to prepare artifacts before the AI session begins, the web compiler is a valid operator-facing surface for filling the opening artifacts, reviewing imports, and exporting a clean opening package. It is not authority — the canonicals still govern — but it keeps required and optional surfaces visible during compilation.

​
What the AI Holds vs. What You Hold

The AI is a protocol-enforcement and artifact-building surface. It reads the canonicals correctly, applies classification rules, flags missing fields, and builds artifacts from templates. It does not decide whether a source is trustworthy, whether the setup is clean enough, or whether now is the right time to open the target project. Those calls belong to you. When in doubt: prefer the smaller move. Prefer explicit files over memory. Prefer NOT_READY over fake readiness. Prefer a reset over contaminated continuity.

Build docs developers (and LLMs) love

Get started for freeTalk to us