GitHub - No3371/projex: A framework to prompt LLM agents to carry out every type of task needed in development works..

Projex is a framework for efficiently prompting LLMs to think, plan, execute in form of self-contained unit files.

By prompting framework it means this is NOT for vibe-coding or autonomous agents, but to optimize collaborative agentic development, allow you to focus even more on supervising and making decisions.

It's kinda like spec-driven development but you actively engage in the process and constantly pilot the LLM, this has some inherent advantages:

• You understand the code/details better because you only delegate the execution part. You also observe agents' mistakes fairly early.
• Becuase "every projex is a self-contained unit of work", development naturally progress in small but meaningful steps.
• Because "everything is a projex document", there's always something to refer to, this greatly lowers the requirement of LLMs' memory/context retrieval capabilities.
• The projex documents are the plans, reports, and also the memory, the cost to start new sessions is very low because you can throw a projex into the new session and continue on.
• This works exceptionally with git.

These are workflows (not skills) we constantly call and chain, and the workflows cover basically all types of instructions we give out. So in practice it will be like /plan-projex followed by /execute-projex and then if everything goes well you say /close-projex. Every call to the workflows is like a context adjustment to guide LLMs to keep up with the rules and best practices.

Example1:

> /eval-projex potential solutions to optimize the lookup (this gives a evaluation projex document
> /plan-projex plan for the option A (I don't need to reference the projex for the agent to understand
> /execute-projex (It starts to execute on a ephemeral git branch
> /close-projex (It concludes the task and cleans up everything

Example2:

> /navigate-projex  (this creates a navigation projex document
> /plan-projex 20260131-v1-foundation-roadmap-nav.md#L108 (Ask the agent to plan for a objective

Example3:

> 20260207-v1-foundation-roadmap-eval-review.md 20260131-v1-foundation-roadmap-eval.md
plan-projex.md phase3
(asking the agent to make plan for phase 3 based on the eval and the review to the eval)

This started as an attempt to "tame" Gemini 3 Pro, a smart but very rushy LLM model. The framework has been proven useful and re-shaped how I interact with LLM agents in general.

Note1: Workflow is Antigravity's "command", and the workflows folder is made for AG for /slash usage. For Claude Code, simply mentioning the name of the workflows should work even without making them commands in Claude Code.

Note2: I proposed and designed the core principles for the workflows, Sonnet/Opus filled the details and revise them based on my requirements and feedback.

-- The following is authored by Opus --

Why Not Just Prompt?

Agents forget what they did, skip steps, lose context between sessions, and leave no trace. Projex gives them:

• Memory — Decisions, rationale, and plans persist in files. Next session picks up where this one left off.
• Traceability — Every change links to a plan, every plan links to a walkthrough. "Why was this done?" always has an answer.
• Guard rails — Templates make agents think about scope, risks, and rollback before acting, not after.
• Safe undo — Ephemeral branches and simulations let agents try things that can be cleanly discarded.
• Scalability — Focused units chain together. One prompt can't manage a multi-step project; a folder of projex documents can.
• Learning — Walkthroughs capture what worked, what broke, and what to avoid. The project accumulates knowledge.

How It Works

Self-contained markdown documents in projex/ folders. Each has a type, template, and lifecycle. Named {yyyymmdd}-{name}-{type}.md, organized by state:

projex/                    # Active/pending
projex/closed/             # Completed
projex/archived/           # Superseded or shelved
projex/abandoned/          # Discarded (rare)

Repos can have multiple projex/ folders scoped to different areas (e.g., docs/projex/, src/projex/), managed independently.

Document Types

Ideation & Analysis

Specification & Orientation

Planning & Execution

Quality & Validation

Knowledge Gathering

How Workflows Connect

Not a pipeline. Building blocks that chain freely — any output can trigger any workflow.

           ┌─────────────┐
  ┌───────>│   Review    │───────┐
  │        └─────────────┘       │
  │        ┌─────────────┐       │  findings
  │   ┌───>│  Red Team   │───┐   │  feed back
  │   │    └─────────────┘   │   │
  │   │    ┌─────────────┐   │   │
  │   ├───>│   Audit     │───┤   │
  │   │    └─────────────┘   │   │
  │   │                      ▼   ▼
  │   │    ┌──────────────────────────────────────────┐
  │   │    │ Proposal / Eval / Explore / Imagination  │
  │   │    └──────┬───────────────────────────────────┘
  │   │           │                              ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
  │   │          ┌┴──────────────────┐            Define · Navigate · Map
  │   │          ▼                   ▼           │ Guide · Interview · Imagine │
  │   │    ┌───────────┐      ┌────────────┐       auxiliary — can inform
  │   │    │   Plan    │─────>│   Patch    │     │  or be informed by any    │
  │   │    └─────┬─────┘      │ (act+doc)  │           workflow above
  │   │          │            └────────────┘     └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
  │   │          │ ◄── review/redteam plan
  │   │          │     before execution
  │   │    ┌─────┴──────┐
  │   │    ▼            ▼
  │   │ ┌────────┐ ┌──────────┐
  │   │ │Execute │ │ Simulate │
  │   │ └───┬────┘ │(try+undo)│
  │   │     │      └──────────┘
  │   │     ▼
  │   │ ┌──────────┐
  │   │ │  Close   │
  │   │ │(walkthru)│
  │   │ └────┬─────┘
  │   │      │
  └───┴──────┘
    any output can trigger
    another workflow

Common Chains

Patterns, not rules.

Git Integration

• Execute/Close — ephemeral branch (projex/{yyyymmdd}-{name}), merged or abandoned at close
• Simulate — throwaway branch (projex/sim/{yyyymmdd}-{name}), always discarded
• Patch — commits directly to current branch
• Log — observes existing changes (staged or committed); commits only the log document itself
• Definition / Navigate / Map — operates on current branch, revised in-place (living documents)
• Everything else — operates on current branch

Discipline

• Sequential git commands, verified one at a time
• Stage files by explicit path — never git add ., git add -A, git add -u, or directories
• Multi-repo workspaces: confirm which repo before any git operation

File Reference

All workflow specs live in .agent/skills/projex-framework/.