Skip to main content

​
The art of prompting

Effective communication is the key to successful building with Workshop. Think of prompting as a collaborative conversation — the clearer you are about what you want, the better Workshop can deliver. This guide covers principles and practical phrases organized by intent.

​
Core principles

​
Be specific and descriptive

Vague prompts produce generic results. Specificity gives Workshop the information it needs to make the right technical and design decisions. 
Make me a website.

​
Provide context and purpose

Tell Workshop why you’re building something, not just what. Context about your situation, audience, and constraints leads to better architectural decisions. 
Build a database.

​
Iterate and refine

Building software is iterative. Instead of expecting perfection on the first try, guide Workshop through incremental improvements with specific feedback. 
This isn't right. Fix it.

​
Prompting by intent

​
Starting a project

Give Workshop a clear picture of what you’re building, who it’s for, and what success looks like. 
I'd like to create a fitness tracking app called "FitTracker". The goal is to
monitor workouts, nutrition, and progress toward specific fitness goals. It's
for personal use, so keep it simple.

Let's build a recipe management app for home cooks. Core features: recipe storage
with categories, ingredient lists with unit conversion, meal planning calendar,
and a shopping list generator.

​
Setting technical parameters

If you have preferences or constraints, state them early. Otherwise, let Workshop (especially Plan Mode) recommend the best approach. 
For this project, use the MERN stack — we need both a responsive frontend and
a robust backend. The target audience is home cooks comfortable with technology
but not technical experts.

This needs to work on desktop browsers, iOS, and Android. Must be responsive
and work offline with data sync when connection is restored.

​
Describing design and UI

Reference specific styles, colors, layouts, and interaction patterns rather than abstract adjectives. 
The interface should follow a minimalist design with navy, white, and light gray.
Use subtle shadows and rounded corners for a modern feel.

Add a navigation menu with Home, Products, Services, About, and Contact. Fixed
at the top, collapses into a hamburger on mobile. Highlight the active page.

​
Defining functionality

Describe user interactions as specific scenarios — what the user does, what should happen, and what edge cases to handle. 
When a user clicks "Submit", validate all form fields. If validation fails,
show error messages below the problematic fields. On success, send the data
and show a confirmation.

Users should filter products by category dropdown and price range slider.
Update the product list immediately without a page refresh.

​
Backend and API work

Specify data models, integrations, performance requirements, and security considerations. 
Connect to the OpenWeatherMap REST API. Authenticate with our API key, fetch
current weather and 5-day forecast, and cache responses for 30 minutes.

Create a database schema: Users (id, name, email, password_hash, created_at),
Products (id, name, description, price, inventory_count, category_id),
Orders (id, user_id, total, status, created_at). Users have many Orders,
Products belong to Categories, Orders have many Products via OrderItems.

​
Testing and quality

Be explicit about what to test, coverage expectations, and the types of testing you need. 
Write tests for user authentication: successful login, wrong password,
account lockout after multiple failures, and password reset flow. Verify
error messages and security logs.

Run the application and test this phase thoroughly before moving to the next one.
Focus on edge cases around empty states and error handling.

​
Debugging and troubleshooting

Describe what you expected, what actually happened, and any relevant context about when the issue occurs. 
The contact form fails silently when attachments exceed 5MB. Instead of a blank
error page, show a user-friendly message with the file size limit.

Search only returns exact keyword matches. It should also return partial matches
and handle misspellings. Let's debug why the fuzzy matching isn't working.

​
Requesting changes

Be specific about what to change, where to change it, and why. 
On the product detail page: 1) Move description above specifications,
2) Make images larger with a zoom feature, 3) Add a "Frequently bought
together" section at the bottom.

The results ranking needs improvement — users have to type exact product names.
Modify it to handle misspellings and partial matches.

​
Deployment

Specify your target platform, environment configuration needs, and any CI/CD requirements. 
Prepare this for deployment on AWS Elastic Beanstalk. Database connection
strings, API keys, and logging levels should be environment variables.
Serve static assets from CloudFront.

Set up a GitHub Actions pipeline: run tests and build on push to develop,
deploy to staging automatically. Production deploy only on merge to main
with manual approval.

​
Advanced prompting techniques

​
Combining approaches

Use a hybrid approach: React with server components for the frontend (we need
interactivity and good SEO) and Go microservices for backend processing
(high-throughput data with minimal resources).

​
Performance optimization

The product listing is slow with 100+ items. Optimize with lazy loading for
images, reduced JavaScript bundle, and pagination. Goal: 40% better load
time and 60% better time-to-interactive.

​
Architecture discussions

I'm considering two approaches: a monolith with server-side rendering, or
microservices with a separate SPA. We need to support 10,000 daily users
with frequent feature updates and multiple third-party integrations.
Can we discuss the trade-offs?

​
Tips for better results

Start with Plan Mode

For new projects, begin in Plan Mode. It helps you define clear requirements even from vague ideas and creates a structured plan for Build Mode.

Work incrementally

Build features one at a time. Get core functionality working before adding complexity. This makes debugging easier and progress more visible.

Use custom instructions

Set consistent preferences in Agent Settings so you don’t repeat the same guidance in every conversation. See Agent Settings for details.

Leverage project context

Keep your .memex/context.md updated so Workshop always understands your project’s current state, conventions, and constraints. See Context Management.