Skip to content

Prompt Cheat Sheet

This page is a quick reference: each step has a prompt you can copy as-is, plus who is responsible for running it. For full walkthroughs, read Quick Start, First AI Collaboration, and Adopt Existing Project.

This page is written for OpenLogos 0.16.7 (check yours with openlogos --version).

1. Documents come before code. OpenLogos moves from Why → What → How: requirements first, then product design, then architecture, scenario sequence diagrams, API / DB, test cases, and finally code. Each step’s output is the AI’s context for the next step, so document quality directly determines code quality.

2. The AI writes, you confirm. The AI produces documents and code by following Skills; you review and decide at key points (see “Human confirmation points” below).

3. The write guard decides who runs what. Once a project is launched, code cannot change without an active change proposal. Guard strength differs between AI tools — in some tools the AI cannot run commands like openlogos merge for you, and you run them in a terminal yourself. See “Differences between AI tools” below.

The AI does not perform these actions without your explicit authorization:

Confirmation pointMeaning
Approve the planAfter the change proposal (proposal.md + tasks.md) is written, deltas start only after you approve
openlogos mergeMerge the proposal’s spec deltas into the main documents
openlogos verifyRun tests and produce the acceptance report
Deployment and openlogos smokeOnly when the proposal requires deployment
openlogos archiveArchive the change proposal
git pushPush the code
You want toSay to the AI
Know what to do nextWhat should I do now? Run openlogos next and give me the next step and a ready-to-use prompt
See overall progressRun openlogos status and summarize the current phase, the active proposal, and the next confirmation point
Understand a guard denialThat action was denied by the OpenLogos guard. Explain why and tell me what to do next
Report a bugI found a problem: <symptom>. Only analyze it and propose a fix — do not change any code
Review codeUse the code-reviewer Skill to review <file or module>

openlogos next itself prints a ready-made “Tell AI: …” prompt. When unsure, run next first.

Scenario A: Build a system from new requirements

Section titled “Scenario A: Build a system from new requirements”

A new project (openlogos init) starts in the initial lifecycle and moves through the phases in order. Advance one phase at a time, and review each phase’s output before moving on.

PhaseSay to the AIOutputWhat to review
Phase 1 RequirementsHelp me write the requirements document. Product background: <one sentence: what it is, who it is for, what problem it solves>logos/resources/prd/1-product-requirements/Scenarios (S01, S02, …) are complete; acceptance criteria are testable; the “out of scope” list is explicit
Phase 2 Product designCreate the product design based on the requirementslogos/resources/prd/2-product-design/Interaction flows and error paths; for GUI products, click through the HTML prototypes in a browser
Phase 3-0 ArchitectureDesign the technical architecture based on the requirements and product design. Constraints: <language, framework, database, deployment environment, team standards>prd/3-technical-plan/1-architecture/Technology choices match team standards; module boundaries
Phase 3-1 Scenario modelingWrite scenario implementation documents and sequence diagrams for all scenarios (many scenarios: Model S01 and S02 first)prd/3-technical-plan/2-scenario-implementation/Sequence steps and error branches
Phase 3-2 API and DBDesign the API and database from the scenario sequence diagramslogos/resources/api/, logos/resources/database/Every endpoint traces back to a sequence diagram; tables, indexes, constraints
Phase 3-3 Deployment planDesign the deployment plan and smoke verification strategyprd/3-technical-plan/3-deployment/Environments, rollback, smoke commands
Phase 3-4 Test casesDesign unit test and scenario test cases for all scenarios; for API projects add Design the API orchestration testslogos/resources/test/, logos/resources/scenario/Case IDs (such as UT-S01-01) cover normal and error paths
Phase 3-5 ImplementationSee “Implement in batches” belowBusiness code + test code + reporterEach batch’s case IDs match the test documents
Phase 3-6 AcceptanceRun openlogos verifylogos/resources/verify/acceptance-report.mdThe result is PASS; hand failing cases back to the AI

The more specific your Phase 1 answers, the better everything downstream. You can send this in one message:

Help me write the requirements document.
- What the product is: <one sentence>
- Target users: <a concrete role>
- Problem to solve: <how it is done today and where it hurts>
- Core goal and how to measure it: <e.g. "review time drops from 2 days to 4 hours">
- Must-have features: <3–6 items>
- Explicitly out of scope: <list them to prevent scope creep>
- Constraints: <compliance, existing systems to integrate, launch date, etc.>

For larger projects, split Phase 3-5 by scenario or sub-module, and close the loop in every batch:

Run Phase 3 Step 5 for this implementation; this batch covers only <S01 or a sub-module>.
Every batch must deliver together: (1) business code; (2) the matching UT/ST test code; (3) the OpenLogos
reporter writing to logos/resources/verify/test-results.jsonl.
Before writing code, list the UT/ST case IDs this batch covers and align them with logos/resources/test/.

Do not postpone tests to a final batch.

openlogos launch checks that the module is ready: acceptance has passed, and a module that requires deployment also needs a deployment report and a passing smoke run. So after Phase 3-6 acceptance passes:

  1. Projects that deploy (the default):
    • Say Execute the deployment according to the deployment plan (the deployment-executor Skill; deployment is a human confirmation point). When it finishes it writes logos/resources/verify/deployment-report.md.
    • Run openlogos smoke until it passes (logos/resources/verify/smoke-report.md shows PASS).
  2. Projects that explicitly do not deploy: declare deployment_required: false for the module in logos/logos-project.yaml (or add deployment to its skip_phases); launch then no longer requires deployment or smoke.
  3. Run openlogos launch to move the project into the launched lifecycle.

From then on every change follows “Change proposal workflow” below, the same as Scenario B. Command details: openlogos smoke and openlogos launch.

Scenario B: Understand an existing project and add a feature

Section titled “Scenario B: Understand an existing project and add a feature”
  1. Run openlogos adopt in the project root. The project goes straight to the launched lifecycle — you do not have to backfill historical documents first.
  2. Fill in tech_stack in logos/logos-project.yaml; projects without an HTTP API or database declare the applicable skip_phases.
  3. Check that verify.pre_run_command in logos/logos.config.json is your test command.
  4. Add the OpenLogos reporter to your test framework and put case IDs in test names.

Details: Adopt Existing Project.

Reading files is never blocked by the write guard, so code analysis is available at any time. Do it before starting each new feature.

Whole-codebase survey:

Read through this project's code. Only analyze — do not modify any file. Report:
1. Module layout and what each directory is responsible for
2. Core business flows (described as user scenarios, with entry points: routes, pages, commands, scheduled jobs)
3. Data model and main tables
4. External dependencies (other systems, middleware, third-party services)
5. Test status (framework, coverage, how to run)
6. Technical debt and risks you see

Impact analysis for a new feature:

I want to build a new feature: <description>. Only analyze — do not modify anything:
1. Which modules, files, endpoints, and tables need to change or be added
2. Which existing behavior must stay unchanged
3. Which existing business scenarios are involved
4. A suggested approach, and the questions you need me to answer

Go straight to “Change proposal workflow” below. When filling in the proposal, hand the impact analysis to the AI:

Help me fill in change proposal <slug>. Requirement: <feature description>.
Use the impact analysis above as evidence, and for scenarios this change touches that have no spec documents yet, write their specs from the current behavior.

You never backfill everything up front: each change writes the specs for the scenarios it touches, and logos/resources/ grows with every proposal.

This applies after launch in Scenario A and to everyday work in Scenario B. In the “Who runs it” column, “you / AI” depends on your AI tool — see the next section.

#StepCommand or promptWho runs it
1Create the proposalopenlogos change <slug> (lowercase with hyphens, e.g. add-export-excel)you / AI
2Write the planSay: Help me fill in change proposal <slug>. Requirement: <description>AI
3Check the planopenlogos change-lint, must exit 0you / AI
4Approve the planReview proposal.md and tasks.md, then say: Plan approved. Produce the deltas item by item from tasks.mdyou
5Check the deltasopenlogos change-lintyou / AI
6Merge the specsAfter reviewing the deltas, run openlogos merge <slug>you authorize
7Plan slicesSay: Specs are merged. Use slice-planner to plan the code slices; the slices are written by openlogos slice plan --file <file>AI + you / AI
8Approve slicesReview the slices, then say: Slices approved. Start implementingyou
9ImplementThe AI writes code and tests; when tests fail, paste the output as-is: Test results below, please fix: <output>AI
10Acceptanceopenlogos verifyyou authorize
11Deploy and smokeOnly when the proposal has [deploy] tasksyou authorize
12Archiveopenlogos archive <slug>you authorize
13Pushgit pushyou authorize

Only one proposal can be active at a time; archive it before opening the next.

Kind of changeAfter creating the proposal, say
New featureHelp me fill in change proposal <slug>. Requirement: <description>
Requirement changeHelp me fill in change proposal <slug>. Requirement <X> changes to <Y> because <…>
Interface changeHelp me fill in change proposal <slug>. Endpoint <path> needs <change>; the design stays the same
Bug fixHelp me fill in change proposal <slug>. Symptom: <…>; steps to reproduce: <…>; expected: <…>

A code-only proposal with no spec delta still runs openlogos merge <slug> (a “no-delta merge”) before slice planning.

The prompts are the same in every tool. What differs is how commands are triggered and whether the AI can run CLI commands for you.

  • Triggering commands: slash commands /openlogos:status, /openlogos:next, /openlogos:change, and so on; Skills load automatically from the conversation.
  • Guard: full strength. File edits are blocked beforehand; shell commands get a pre-check and a post-execution comparison.
  • Who runs it: the AI can run openlogos commands for you. Human confirmation points (merge, verify, deployment, smoke, archive, git push) still need your explicit authorization in the conversation, e.g. Run openlogos merge <slug>.

More detail: PreToolUse Guard and each tool’s plugin spec page.

  1. Advance one phase or one scenario at a time: Do S01 first produces much better output than Do all scenarios.
  2. Name the file: Based on section 3 of logos/resources/prd/1-product-requirements/<file> … is more precise than Based on the requirements.
  3. Ask before writing: Before you start, list the questions you need me to answer — especially for Phase 1, Phase 3-0, and change proposals.
  4. Add “only analyze, do not modify” to analysis requests so the AI does not start editing.
  5. Put team constraints in the prompt: tech stack, coding standards, security and compliance requirements. State them in Phase 3-0 and in change proposals; they go into the documents and carry forward.
  6. Paste errors verbatim: terminal output and test failures, not a paraphrase.
  7. Start a new session after long conversations: after each phase or slice. The context lives in the documents, so nothing is lost.

The AI behaves the same after upgrading OpenLogos? Run openlogos sync in each project root, then start a new AI session.

Do I have to backfill historical documents for an existing project? No. After adopt you can open your first change proposal right away.

One repository has several subsystems? Register them with openlogos module add <name>; each tracks its own phases and lifecycle.

Can the whole workflow run fully automatically? Fully automatic mode, openlogos next --auto, is driven by an orchestrator such as RunLogos; see openlogos next. In a normal conversation, use the semi-automatic flow on this page.

Do small changes need a proposal too? After launch, every code change goes through a proposal (non-methodology files such as README are exempt). Small proposals are light: a few lines of plan, and a no-delta merge when there is no spec delta.