-
Notifications
You must be signed in to change notification settings - Fork 0
My Current AI‐Assisted Development Framework
This framework is a stack-agnostic workflow system for managing context, architectural discipline, and implementation continuity across multi-AI development sessions. It bridges two AI systems — ChatGPT acting as architect and Claude Code acting as implementation engine — using a structured set of files that live directly in the project repository.
The framework was designed to solve a specific problem: AI sessions are stateless, but software projects are not. Without deliberate context preservation, each new session starts blind, leading to architectural drift, repeated decisions, and inconsistent implementation quality.
Each AI plays a distinct role:
| Role | Tool | Responsibility |
|---|---|---|
| Architect | ChatGPT | Decisions, tradeoffs, ADRs, prompt generation |
| Implementation engine | Claude Code | Code, branches, PRs, validation |
| Relay | You | Paste prompts in, paste handoffs back |
The repository is the shared memory between both systems. Neither AI needs to remember anything — the repo holds the state, and both AIs read from it at session start.
The boot block is the core primitive of the framework. It is a compact, structured snapshot of
project state that lives at the top of CLAUDE.md. Claude Code reads it automatically at the
start of every session.
A boot block contains:
- Current prompt ID and last completed task
- What is verified stable
- What is in-flight or broken
- The active task for this session
- Architectural laws that must never be violated
- Known technical debt summary
- What to ignore in the codebase
The boot block is updated after every session. It is the single source of truth for Claude Code.
project-root/
│
├── CLAUDE.md ← Auto-loaded by Claude Code. Contains the live boot block,
│ architectural laws, common commands, and key file paths.
│
├── .claude/
│ └── commands/
│ ├── handoff.md ← /handoff — generates session summary + next prompt draft
│ ├── remembernow.md ← /remembernow — confirms state at session start
│ ├── update-boot-block.md ← /update-boot-block — guided CLAUDE.md update
│ └── new-task.md ← /new-task — scaffolds next prompt
│
└── docs/
└── context/
├── chatgpt-primer.md ← Paste into ChatGPT to restore architect context
├── architecture-decisions.md ← Full ADR reference (linked from CLAUDE.md)
├── technical-debt.md ← Full debt register (linked from CLAUDE.md)
├── boot-blocks/ ← Chronological archive of session handoffs
│ ├── README.md
│ ├── CC-XXXX-000001-boot.md
│ └── CC-XXXX-000002-handoff.md
└── archive/ ← Retired legacy context files
Every development session follows this exact sequence:
- Open a fresh Claude Code session in VS Code
- Type:
Read CLAUDE.md and confirm current state - Claude confirms boot block ID, last task, next task, branch status
- Paste the CC-XXXX prompt from ChatGPT
- Claude implements on a feature branch
- Run
/handoffin Claude Code - Claude outputs: session summary + boot block update fields + next prompt draft
- Copy the handoff output
- Paste into ChatGPT for architect review
- ChatGPT ratifies or refines the next prompt draft
- Update
CLAUDE.mdboot block fields - Archive handoff to
docs/context/boot-blocks/ - Commit and push
- Run:
cat docs/context/chatgpt-primer.md - Copy the output
- Paste into a new ChatGPT chat as the first message
- ChatGPT confirms current state
- Request the next CC-XXXX prompt when ready
Every Claude Code task is a structured prompt with a unique ID. The ID schema is project-specific:
CC-[PROJECT]-XXXXXX
Examples: CC-ERATE-000029, CC-NOTES-000001, CC-CRM-000004
Every prompt must include these sections:
Before starting this task:
git checkout main
git pull
git checkout -b feature/<task-name>
CC-XXXX-XXXXXX — Task title
## Objective
## Context
## Primary Goals
## Requirements
## Constraints
## Validation
## Deliverable
Use this exact prompt ID in your response: CC-XXXX-XXXXXX
The framework enforces discipline through explicit rules in both CLAUDE.md and chatgpt-primer.md:
Architectural Laws — immutable rules that neither AI may violate without explicit human approval. Defined once, referenced in every session.
ADRs (Architecture Decision Records) — every major decision is recorded with what was decided, why, and what was rejected. Settled decisions are never re-debated.
Non-Goals — explicitly listed items that are out of scope. Prevents both AIs from suggesting improvements that violate project constraints.
Technical Debt Register — known debt is tracked with risk level and recommended resolution path. Neither ignored nor acted on without deliberate prioritization.
Every task follows this exact loop — no exceptions:
main → feature branch → implement → PR → CI green → merge → delete branch → sync main
Rules:
- Never commit directly to main
- Never skip the PR
- Always delete branches after merge
- Always sync main before starting the next task
The framework operates entirely at the workflow layer, not the code layer. It works with any stack:
| Component | Stack dependency |
|---|---|
| CLAUDE.md | None — content changes, structure stays identical |
| chatgpt-primer.md | None — project identity changes, format stays identical |
| Slash commands | None — no code references |
| Boot block structure | None — fields are universal |
| Prompt schema | None — sections are universal |
| Git workflow | None — branch discipline is universal |
To start a new project with this framework, copy the template files, update the content placeholders (stack, project name, prompt ID prefix), and the system is operational.
| Convention | Rule |
|---|---|
| Boot block update | After every Claude Code session |
| ChatGPT restore | Paste chatgpt-primer.md contents directly — never use URLs |
| Handoff archive | Every session handoff saved to boot-blocks/ by prompt ID |
| Prompt ratification | ChatGPT always reviews and approves the next prompt before use |
| Task scope | One prompt = one task. Never multi-feature prompts. |
| Context window | Run /handoff at 80% context usage — never wait for compaction |
The framework solves the core failure mode of multi-AI development: context loss at session boundaries. By making the repository the shared memory layer, both AIs always start from a known, accurate state. The human relay role is reduced to copying and pasting structured outputs — no summarization, no interpretation, no reconstruction.
The result is a development system that compounds over time rather than drifting. Each session builds cleanly on the last. Architectural decisions stay settled. Implementation quality stays consistent. The project moves forward in small, disciplined, high-value increments.