Skip to main content

​
Why two modes?

The success of building with AI depends heavily on the quality of planning and prompting. But prompt engineering is a skill that takes practice. Workshop addresses this with Plan Mode — an experienced technical product manager that guides you through critical thinking before you start building. Together, Plan and Build modes create a complete development workflow: think first, then build with confidence.

​
Plan Mode: your strategic partner

Plan Mode solves the “garbage in, garbage out” problem. Instead of jumping straight into code, it guides you through structured requirements gathering to ensure Build Mode has a clear, actionable foundation.

​
What Plan Mode does

  • Guides you toward choices that set you up for success
  • Helps you think through trade-offs of different technical and business decisions
  • Scopes down to an MVP before expanding — build something valuable first
  • Steers you toward solutions that get you to value quickly
  • Pushes back on your ideas when appropriate, like an experienced PM would

​
How Plan Mode works

Plan Mode follows a structured approach to requirements gathering, adapted to your specific project:
1

Discovery

Plan Mode asks probing questions to understand your true needs. It uses structured multiple-choice questions for clear, efficient communication — typically no more than 3 questions total, one per turn.
2

Requirement Clarification

Based on your answers, Plan Mode digs deeper into areas that need clarification — sharing strategy, design requirements, scalability, integrations, and deployment.
3

MVP Scoping

Plan Mode helps identify the smallest version that delivers real value. It actively steers away from scope creep and heavyweight infrastructure unless justified.
4

Plan Summary Checkpoint

Before generating the plan, Plan Mode presents a concise summary of scope, technical decisions, and implementation phases. You review and approve — or request adjustments — before proceeding.
5

Plan Generation

Once confirmed, Plan Mode creates a structured plan.md file that Build Mode can follow step by step.

​
The plan document

Plan Mode generates a plan.md file saved in your project under ./plans/[timestamp_topic-name]/. Each plan is append-only — new plans never overwrite existing ones, preserving your decision history. The plan includes:
  • Spec Header — Name, smallest scope, non-goals
  • Decision Snapshot — Key technical and product decisions
  • Architecture at a Glance — Recommended stack and structure
  • Implementation Plan — Step-by-step development phases
  • Verification & Demo Script — How to test each phase
  • Deploy — Deployment strategy

​
Plan Mode’s technical preferences

Plan Mode has strongly-held opinions optimized for shipping quickly:
PreferenceOverRationale
Hosted platforms (Netlify, Modal)Docker, AWS, GCPLess ops burden, faster first version
Web appsMobile appsBrowser-based validation before app stores
Cross-platform (React Native, Tauri)Native iOS/AndroidBroader reach, single codebase
Lightweight (SQLite, FastAPI)Heavy (Postgres, Django)Right-sized for MVPs
Plan Mode will politely push back if you request heavyweight infrastructure that isn’t justified by your scope.

​
Plan Mode tools

Plan Mode has access to a focused set of read-only tools:
  • plan_question — Structured multiple-choice questions with keyboard navigation
  • template_question — Guided template selection during planning
  • read_file — Inspect existing project files and code
  • grep_search — Search through codebases
  • search_templates — Find relevant starter templates
  • git_clone — Clone template repositories into your project
  • search — Research technologies and best practices
  • fetch_web — Retrieve documentation and references
  • generate_plan — Create the final plan document
Plan Mode cannot modify files or execute code. It is strictly read-only, ensuring that planning stays separate from implementation.

​
Build Mode: your implementation partner

Build Mode takes structured plans — or ad-hoc requests — and turns them into working software. It has full access to Workshop’s tool suite for writing code, managing files, and running applications.

​
Build Mode capabilities

Code Development

Writes code in any language, follows architectural patterns, implements features incrementally.

Environment Management

Sets up dependencies, manages virtual environments, handles configuration and setup.

File Operations

Creates and manages project files, organizes code following best practices, maintains documentation.

Testing & Debugging

Runs applications, debugs issues, implements fixes, verifies functionality.

Version Control

Initializes git repositories, commits at logical milestones, maintains clear history.

Interactive Terminal

Handles command-line tools that require interactive input — scaffolding, installers, deployment wizards.

​
Working with a plan

When Build Mode receives a plan from Plan Mode, it:
  • Follows the implementation sequence outlined in the plan
  • Makes technical decisions aligned with the plan’s strategic choices
  • Stays focused on the current phase while keeping future phases in mind
  • Adapts the plan when technical realities require adjustments

​
Beyond planned development

Build Mode also handles unplanned work: 
Add a dark mode toggle to this application and make sure it persists user preference.

This API is returning different data than expected. Debug the issue and fix the processing.

Convert this Python script into a web application with a simple interface.

​
Working across modes

​
Switching between modes

Switch modes at any time using the toggle below the conversation input. Click to switch — no need to ask Workshop.
  • Plan to Build: After completing your planning phase, toggle to Build Mode to begin implementation.
  • Build to Plan: When you need strategic guidance during development, toggle back to Plan Mode for architectural decisions or feature planning.
The mode persists across sessions via your local preferences (defaults to Build Mode).
  1. Plan Mode — Define requirements, scope the MVP, create a development plan
  2. Build Mode — Implement Phase 1 of the plan
  3. Plan Mode — Evaluate results, plan Phase 2
  4. Build Mode — Continue implementation

​
Best practices

​
Plan Mode

  • Be open to questions and pushback. Let Plan Mode guide you toward a focused, achievable scope rather than insisting on building everything at once.
  • Share context about your situation. The more Plan Mode knows about your constraints, skills, and goals, the better it can tailor recommendations.
  • Be honest about your technical comfort level. Plan Mode adjusts its recommendations based on what you can maintain and deploy.

​
Build Mode

  • Reference the plan. Point Build Mode to the specific phase or feature you want implemented.
  • Work incrementally. Get core functionality working before adding advanced features.
  • Test and verify. Ask Workshop to run and test each phase before moving on.
  • Save progress. Commit working code at milestones and update documentation.

​
Mode-specific custom instructions

You can set preferences that apply differently in each mode: 
In Plan Mode: Always consider mobile-first design and simple deployment options.
In Build Mode: Prioritize code readability and include comprehensive error handling.
Both modes respect project-specific context stored in your .memex/context.md file, ensuring consistent behavior across conversations and modes.