
replit-prompts
Generate optimized prompts, PRDs, and task plans for Replit Agent that maximize AI understanding and minimize iterations
- version
- 1.0.0
- GitHub stars
- 16
Install
/plugin install replit-prompts@bershadsky-claude-toolsRun it inside Claude Code after adding the marketplace with /plugin marketplace add sergio-bershadsky/ai.
Contents
Discovered from sourceSkills 3
Replit Task Planner
Break down projects into iterative development phases with checkpoints optimized for Replit Agent's workflow.
When to Use
- Converting a large project into manageable phases
- Planning checkpoint strategy for complex builds
- Creating iterative prompts from a PRD or idea
- Structuring work for Replit Agent's extended autonomy mode
Replit Agent Modes
Build Mode (Default)
- Agent writes code directly
- Best for: Implementation, coding, fixing bugs
- Creates checkpoints automatically
Plan Mode
- Agent discusses without modifying code
- Best for: Architecture decisions, exploring approaches, reviewing PRDs
- Free (no checkpoint charges)
Edit Mode
- Agent makes targeted changes to specific files
- Best for: Precise modifications, refactoring specific sections
Checkpoint Strategy
Replit Agent creates checkpoints after each prompt. Effective planning means:
- One checkpoint = one logical unit of work
- Each phase should be testable independently
- Phases build on each other sequentially
- Rollback-friendly boundaries
Task Breakdown Template
# [Project Name] - Development Plan
## Overview
**Project:** [Brief description]
**Total Phases:** [Number]
**Estimated Checkpoints:** [Number]
---
## Phase 1: [Phase Name]
**Goal:** [One sentence describing what's achieved]
**Dependencies:** None (starting point)
### Tasks
1. [Specific task 1]
2. [Specific task 2]
3. [Specific task 3]
### Deliverables
- [ ] [Testable outcome 1]
- [ ] [Testable outcome 2]
### Prompt for Replit Agent
[Phase goal description]. Specifically:
- [Task 1 with details]
- [Task 2 with details]
- [Task 3 with details]
Stop after completing these tasks so I can review before continuing.
### Verification Steps
- [ ] [How to verify task 1]
- [ ] [How to verify task 2]
---
## Phase 2: [Phase Name]
**Goal:** [One sentence]
**Dependencies:** Phase 1 complete
### Tasks
[...]
### Prompt for Replit Agent
[...]
---
## Rollback Points
- After Phase 1: [What's safe to rollback to]
- After Phase 2: [What's safe to rollback to]
## Risk Mitigation
| Risk | Phase | Mitigation |
|------|-------|------------|
| [Risk] | [Phase #] | [How to handle] |
Procedure
Step 1: Understand the Project
Gather from user:
- What is being built?
- What are all the features/requirements?
- Any dependencies between features?
- Are there external integrations?
Step 2: Identify Natural Boundaries
Look for:
- Setup vs Features — Config/auth first, then features
- Independent Features — Features that don't depend on each other
- Dependent Features — Features that require others to exist
- Polish vs Core — Error handling, edge cases last
Step 3: Create Phases
Phase 1: Foundation Always start with:
- Project setup
- Database schema
- Authentication (if needed)
- Basic navigation/layout
Phase 2-N: Core Features Group related functionality:
- One major feature per phase
- Include its UI, API, and data needs
- Keep phases 30-60 minutes of Agent work
Final Phase: Polish Always end with:
- Error handling
- Loading states
- Edge cases
- Responsive fixes
- Final testing
Step 4: Write Prompts for Each Phase
Each prompt should:
- State the goal clearly
- List specific tasks (numbered)
- Include technical details
- Request a stop point for review
Template:
Implement [Feature Name].
Requirements:
1. [Specific requirement with details]
2. [Specific requirement with details]
3. [Specific requirement with details]
Technical notes:
- [Relevant constraint or approach]
- [Relevant constraint or approach]
Create a checkpoint when complete so I can review before the next phase.
Step 5: Define Verification Steps
For each phase, include how to verify:
- What to click/test in the UI
- What API calls to make
- What database records to check
Step 6: Present the Plan
## Development Plan: [Project Name]
**Phases:** [Number]
**Approach:** [Brief strategy explanation]
---
[Full plan with all phases]
---
## How to Use This Plan
1. **Start with Plan Mode**: Copy Phase 1 prompt, select Plan Mode
2. **Review Agent's approach**: Ensure it aligns with expectations
3. **Switch to Build Mode**: Approve and let Agent implement
4. **Verify at checkpoint**: Test deliverables before continuing
5. **Proceed to next phase**: Copy next prompt and repeat
## Iteration Strategy
If issues arise:
- Minor issues: Describe and ask Agent to fix in current phase
- Major issues: Rollback to previous checkpoint, refine prompt, retry
Ready to start?
Phase Sizing Guidelines
| Phase Size | Work Amount | Example |
|---|---|---|
| Small | 15-30 min | Add a single form with validation |
| Medium | 30-60 min | Full CRUD for one entity |
| Large | 60-90 min | Feature with UI + API + data |
Ideal phase: Medium (30-60 minutes)
Signs phase is too large:
- More than 5 major tasks
- Touches more than 4-5 files
- Multiple unrelated features
- "Build the entire X" language
Signs phase is too small:
- Single task that takes < 10 minutes
- No testable deliverable
- Could easily be combined with adjacent phase
Common Phase Patterns
Pattern 1: CRUD Feature
Phase N: [Entity] Management
1. Database model and migrations
2. API endpoints (list, create, read, update, delete)
3. List view with table/cards
4. Create/edit form (modal or page)
5. Delete with confirmation
Deliverables:
- [ ] Can create new [entity]
- [ ] Can view list of [entities]
- [ ] Can edit existing [entity]
- [ ] Can delete [entity]
Pattern 2: Authentication
Phase 1: Authentication Setup
1. Configure auth provider (Supabase/Clerk/etc.)
2. Create signup page with form
3. Create login page with form
4. Add protected route wrapper
5. Add user context/hook
6. Add logout functionality
Deliverables:
- [ ] New user can sign up
- [ ] Existing user can log in
- [ ] Protected pages redirect to login
- [ ] User can log out
Pattern 3: Dashboard
Phase N: Dashboard
1. Create dashboard layout
2. Add metric cards with data fetching
3. Add recent activity list
4. Add quick action buttons
5. Implement responsive grid
Deliverables:
- [ ] Dashboard loads with correct data
- [ ] Metrics update when data changes
- [ ] Recent activity shows latest items
- [ ] Layout works on mobile
Pattern 4: External Integration
Phase N: [Service] Integration
1. Set up environment variables for API keys
2. Create service wrapper/client
3. Implement core integration function
4. Add error handling for API failures
5. Connect to UI trigger point
Deliverables:
- [ ] API key configuration works
- [ ] Integration function returns expected data
- [ ] Errors handled gracefully
- [ ] UI reflects integration state
Example: Full Task Breakdown
Project: Todo App with Categories
# Todo App - Development Plan
## Overview
**Project:** Todo app with categories, due dates, and search
**Total Phases:** 4
**Estimated Checkpoints:** 5
---
## Phase 1: Foundation
**Goal:** Set up project with database and basic structure
**Dependencies:** None
### Tasks
1. Initialize React + Vite project with TailwindCSS
2. Set up SQLite database with Prisma
3. Create Todo and Category models
4. Set up Express API with basic structure
5. Create app shell with header and main area
### Deliverables
- [ ] Project runs without errors
- [ ] Database creates successfully
- [ ] Empty app shell renders
### Prompt
Set up a Todo app with React, Vite, TailwindCSS, Express, and SQLite with Prisma.
- Initialize React + Vite project
- Add TailwindCSS configuration
- Create Express backend with /api prefix
- Set up Prisma with SQLite
- Create models:
- Category: id (uuid), name (string), color (string)
- Todo: id (uuid), title (string), completed (boolean), due_date (date nullable), category_id (uuid nullable, FK)
- Create basic app layout with header showing "Todo App"
Stop when the shell runs and database migrates successfully.
---
## Phase 2: Category Management
**Goal:** Full CRUD for categories
**Dependencies:** Phase 1
### Tasks
1. API endpoints for categories
2. Category list sidebar
3. Add/edit category modal
4. Delete category with confirmation
5. Color picker for categories
### Deliverables
- [ ] Can create category with name and color
- [ ] Categories display in sidebar
- [ ] Can edit category
- [ ] Can delete category
### Prompt
Implement category management for the Todo app.
-
Create API endpoints:
- GET /api/categories - list all
- POST /api/categories - create new
- PUT /api/categories/:id - update
- DELETE /api/categories/:id - delete
-
Create sidebar showing category list with colored dots
-
Add "New Category" button that opens modal
-
Modal has: name input, color picker (preset colors), save/cancel
-
Category item has edit and delete buttons
-
Delete shows confirmation before removing
Use a simple color picker with 8 preset colors.
Stop when categories can be created, edited, and deleted.
---
## Phase 3: Todo Management
**Goal:** Full todo functionality with categories and due dates
**Dependencies:** Phase 2
### Tasks
1. API endpoints for todos
2. Todo list component with checkboxes
3. Add todo form
4. Edit todo modal
5. Category assignment dropdown
6. Due date picker
7. Filter todos by category (click sidebar)
### Deliverables
- [ ] Can create todo with optional category and due date
- [ ] Can mark todo complete/incomplete
- [ ] Can edit todo details
- [ ] Can delete todo
- [ ] Clicking category filters todos
### Prompt
Implement todo management with category assignment and due dates.
-
Create API endpoints:
- GET /api/todos?category_id=x - list todos, optional filter
- POST /api/todos - create
- PUT /api/todos/:id - update
- DELETE /api/todos/:id - delete
-
Main area shows todo list:
- Checkbox to toggle complete (strikethrough when done)
- Title text
- Category badge (colored)
- Due date badge (red if overdue)
- Edit/delete buttons on hover
-
Add todo form at top:
- Title input (required)
- Category dropdown (optional)
- Due date picker (optional)
-
Click category in sidebar to filter todos (highlight selected)
-
Edit todo opens modal with all fields editable
Sort todos: incomplete first, then by due date (soonest first).
Stop when todos can be fully managed with categories and dates.
---
## Phase 4: Search and Polish
**Goal:** Add search and polish UX
**Dependencies:** Phase 3
### Tasks
1. Search input in header
2. Search filters todos by title (client-side)
3. Empty states for no todos / no results
4. Loading states
5. Error handling with toast messages
6. Responsive design adjustments
### Deliverables
- [ ] Search filters todos in real-time
- [ ] Empty states display appropriately
- [ ] Errors show user-friendly messages
- [ ] Works on mobile screens
### Prompt
Add search functionality and polish the UX.
-
Add search input in header (right side)
-
Search filters todos by title (case-insensitive, client-side)
-
Add empty states:
- No todos: "No todos yet. Add one above!"
- No results: "No todos match your search"
- No category selected + no todos: "Select a category or add a todo"
-
Add loading spinner for initial data fetch
-
Add error toast for API failures
-
Responsive adjustments:
- Mobile: hide sidebar, add hamburger menu
- Sidebar overlays on mobile when menu open
Test all flows and fix any visual issues.
This is the final phase - ensure everything works smoothly.
---
## Rollback Points
- After Phase 1: Clean slate with just structure
- After Phase 2: Categories work, can redo todo implementation
- After Phase 3: Full functionality, can redo polish
## Risk Mitigation
| Risk | Phase | Mitigation |
|------|-------|------------|
| Prisma schema issues | 1 | Test migration before proceeding |
| Filter state complexity | 3 | Use URL params for filter state |
| Mobile responsive issues | 4 | Test each breakpoint individually |
Output Format
# Development Plan: [Project Name]
## Summary
| Metric | Value |
|--------|-------|
| Total Phases | [Number] |
| Estimated Build Time | [Range] |
| Checkpoint Strategy | [Brief] |
---
[Phase-by-phase breakdown with prompts]
---
## Quick Reference
### Phase Prompts (Copy-Paste Ready)
**Phase 1:**
[Prompt]
**Phase 2:**
[Prompt]
[Continue for all phases]
---
## Verification Checklist
After each phase, verify:
- [ ] Phase 1: [Key items]
- [ ] Phase 2: [Key items]
[...]
Ready to begin?
Rules
- ALWAYS start with foundation phase — Setup, schema, auth first
- ALWAYS end with polish phase — Error handling, edge cases last
- ALWAYS include verification steps — Testable deliverables per phase
- ALWAYS size phases appropriately — 30-60 minutes ideal
- NEVER combine unrelated features — One major feature per phase
- NEVER skip rollback planning — Document safe rollback points
- PREFER explicit prompts — Include technical details in each phase prompt
Replit PRD Generator
Create comprehensive Product Requirements Documents optimized for Replit Agent to build complex applications.
When to Use
- Building complex applications with multiple features
- Need stakeholder alignment before development
- Want one-shot autonomous builds (entire app from single prompt)
- Require clear acceptance criteria and testing plans
- Working on team projects that need documentation
PRD vs Simple Prompt
| Aspect | Simple Prompt | Full PRD |
|---|---|---|
| Features | 1-3 | 4+ |
| Pages/Screens | 1-3 | 4+ |
| User Roles | 1 | Multiple |
| Integrations | 0-1 | Multiple |
| Development Time | < 1 hour | Hours to days |
| Iterations Expected | Minimal | Multiple phases |
Rule of thumb: If you can describe it in 10 lines, use a prompt. If you need structure, use a PRD.
PRD Template for Replit
# [Product Name] - Product Requirements Document
## 1. Executive Summary
### Product Name
[Name]
### Version
1.0.0
### Last Updated
[Date]
### One-Line Description
[What it is and who it's for in one sentence]
### Problem Statement
[What problem does this solve? Why does it matter?]
### Success Metrics
- [Metric 1: e.g., "User can complete core task in under 2 minutes"]
- [Metric 2: e.g., "Zero critical bugs in core user flows"]
- [Metric 3: e.g., "Page load time under 3 seconds"]
---
## 2. User Personas
### Persona 1: [Name/Role]
- **Description:** [Who they are]
- **Goals:** [What they want to achieve]
- **Pain Points:** [What frustrates them currently]
- **Tech Comfort:** [Low/Medium/High]
### Persona 2: [Name/Role]
- **Description:** [Who they are]
- **Goals:** [What they want to achieve]
- **Pain Points:** [What frustrates them currently]
- **Tech Comfort:** [Low/Medium/High]
---
## 3. Technical Specifications
### Tech Stack
| Layer | Technology | Rationale |
|-------|------------|-----------|
| Frontend | [Framework] | [Why chosen] |
| Styling | [Library] | [Why chosen] |
| Backend | [Framework] | [Why chosen] |
| Database | [System] | [Why chosen] |
| Auth | [Provider] | [Why chosen] |
| Hosting | Replit Deployments | Default |
### Architecture Overview
[Text diagram or description of system architecture]
### Third-Party Integrations
| Service | Purpose | API Type | Auth Method |
|---------|---------|----------|-------------|
| [Service] | [What for] | REST/GraphQL | API Key/OAuth |
### Environment Variables Required
| Variable | Description | Required |
|----------|-------------|----------|
| DATABASE_URL | PostgreSQL connection string | Yes |
| [VAR_NAME] | [Description] | Yes/No |
---
## 4. Data Model
### Entity: [EntityName]
| Field | Type | Required | Constraints | Description |
|-------|------|----------|-------------|-------------|
| id | UUID | Yes | Primary key | Unique identifier |
| [field] | [type] | Yes/No | [constraints] | [description] |
### Entity Relationships
User (1) ----< (many) Posts Post (1) ----< (many) Comments User (1) ----< (many) Comments
### Database Indexes
- [table].[column] - For [use case]
- [table].[column] - For [use case]
---
## 5. Feature Specifications
### Feature 1: [Feature Name]
#### Description
[What this feature does]
#### User Stories
- As a [role], I want to [action] so that [benefit]
- As a [role], I want to [action] so that [benefit]
#### Functional Requirements
| ID | Requirement | Priority |
|----|-------------|----------|
| F1.1 | [Specific requirement] | Must Have |
| F1.2 | [Specific requirement] | Must Have |
| F1.3 | [Specific requirement] | Nice to Have |
#### UI Components
- [Component 1]: [Description and behavior]
- [Component 2]: [Description and behavior]
#### API Endpoints
| Method | Endpoint | Request Body | Response | Auth |
|--------|----------|--------------|----------|------|
| POST | /api/[resource] | { field: type } | { field: type } | Required |
| GET | /api/[resource]/:id | - | { field: type } | Required |
#### Validation Rules
- [Field]: [Rule, e.g., "Email must be valid format"]
- [Field]: [Rule, e.g., "Password minimum 8 characters"]
#### Error Handling
| Error Condition | Error Code | User Message | System Action |
|-----------------|------------|--------------|---------------|
| [Condition] | 400/401/etc | [Friendly message] | [What happens] |
### Feature 2: [Feature Name]
[Repeat structure above]
---
## 6. UI/UX Specifications
### Design System
- **Primary Color:** [Hex code]
- **Secondary Color:** [Hex code]
- **Background:** [Hex code]
- **Text:** [Hex code]
- **Font Family:** [Font name]
- **Border Radius:** [Value, e.g., 8px]
### Page Layouts
#### Page: [Page Name]
- **Route:** /[path]
- **Layout:** [Description]
- **Components:**
- [Component 1]
- [Component 2]
- **State:** [What state this page manages]
### Navigation Structure
Home (/) ├── Dashboard (/dashboard) ├── [Section] (/[path]) │ ├── [Subsection] (/[path]/[subpath]) │ └── [Subsection] (/[path]/[subpath]) └── Settings (/settings)
### Responsive Breakpoints
| Breakpoint | Width | Layout Changes |
|------------|-------|----------------|
| Mobile | < 640px | [Changes] |
| Tablet | 640-1024px | [Changes] |
| Desktop | > 1024px | [Default layout] |
---
## 7. User Flows
### Flow 1: [Flow Name]
Start → [Step 1] → [Step 2] → [Decision Point] ├── Yes → [Step 3a] → End └── No → [Step 3b] → End
**Detailed Steps:**
1. User [action] on [page/component]
2. System [response/validation]
3. User sees [feedback/result]
4. [Continue...]
### Flow 2: [Flow Name]
[Repeat structure]
---
## 8. Non-Functional Requirements
### Performance
- Page load time: < [X] seconds
- API response time: < [X] ms
- Support [X] concurrent users
### Security
- [ ] Input sanitization on all forms
- [ ] HTTPS only
- [ ] SQL injection prevention (parameterized queries)
- [ ] XSS prevention
- [ ] CSRF tokens on forms
- [ ] Rate limiting on auth endpoints
### Accessibility
- [ ] Keyboard navigable
- [ ] Screen reader compatible
- [ ] Color contrast ratio 4.5:1 minimum
- [ ] Focus indicators visible
### Browser Support
- Chrome (latest 2 versions)
- Firefox (latest 2 versions)
- Safari (latest 2 versions)
- Edge (latest 2 versions)
---
## 9. Scope Boundaries
### In Scope (MVP)
- [Feature/capability 1]
- [Feature/capability 2]
- [Feature/capability 3]
### Out of Scope (Future)
- [Feature/capability 1] - Reason: [why deferred]
- [Feature/capability 2] - Reason: [why deferred]
### Explicit Non-Goals
- [Thing this product will NOT do]
- [Thing this product will NOT do]
---
## 10. Acceptance Criteria
### Feature 1: [Name]
- [ ] [Testable criterion 1]
- [ ] [Testable criterion 2]
- [ ] [Testable criterion 3]
### Feature 2: [Name]
- [ ] [Testable criterion 1]
- [ ] [Testable criterion 2]
### Overall Application
- [ ] All pages load without errors
- [ ] All forms validate correctly
- [ ] All API endpoints return expected responses
- [ ] Mobile layout is functional
- [ ] No console errors in production
---
## 11. Development Phases
### Phase 1: Foundation (Checkpoint 1)
**Goal:** Basic structure and auth
- [ ] Project setup with tech stack
- [ ] Database schema and migrations
- [ ] Authentication flow
- [ ] Basic navigation/layout
### Phase 2: Core Features (Checkpoint 2)
**Goal:** Primary functionality
- [ ] [Core feature 1]
- [ ] [Core feature 2]
### Phase 3: Polish (Checkpoint 3)
**Goal:** UX and edge cases
- [ ] Error handling
- [ ] Loading states
- [ ] Responsive design
- [ ] Form validations
### Phase 4: Launch (Checkpoint 4)
**Goal:** Production ready
- [ ] Final testing
- [ ] Performance optimization
- [ ] Security review
- [ ] Documentation
---
## 12. Risks and Mitigations
| Risk | Impact | Probability | Mitigation |
|------|--------|-------------|------------|
| [Risk 1] | High/Med/Low | High/Med/Low | [How to address] |
| [Risk 2] | High/Med/Low | High/Med/Low | [How to address] |
---
## 13. Appendix
### Wireframes/Mockups
[Links or embedded images]
### Reference Applications
- [App name](URL) - Similar [feature/design]
- [App name](URL) - Similar [feature/design]
### API Documentation Links
- [Service]: [URL]
### Glossary
| Term | Definition |
|------|------------|
| [Term] | [Definition] |
Procedure
Step 1: Gather High-Level Requirements
Ask the user:
- What is the product and who is it for?
- What are the 3-5 most important features?
- Any specific tech requirements or preferences?
- Any reference apps or designs to emulate?
Step 2: Define User Personas
For each user type:
- Who are they?
- What do they need to accomplish?
- What's their technical skill level?
Step 3: Detail Features
For each feature, extract:
- User stories
- UI components needed
- Data required
- API endpoints
- Validation rules
- Error scenarios
Step 4: Design Data Model
- List all entities
- Define all fields with types and constraints
- Map relationships
- Identify required indexes
Step 5: Specify UI/UX
- Color palette
- Page layouts
- Navigation structure
- Responsive behavior
- Key interactions
Step 6: Define User Flows
Document step-by-step:
- Happy path
- Error paths
- Edge cases
Step 7: Set Acceptance Criteria
Create testable checkboxes for:
- Each feature
- Overall functionality
- Performance requirements
Step 8: Plan Development Phases
Break into 3-4 phases with:
- Clear goals
- Specific deliverables
- Checkpoint criteria
Step 9: Present Draft PRD
## PRD Draft: [Product Name]
**Complexity:** [Low/Medium/High]
**Estimated Phases:** [Number]
**Primary Persona:** [Name]
---
[Full PRD content]
---
## Usage Instructions
1. Copy entire PRD to Replit Agent
2. Use Plan Mode first to review Agent's approach
3. Approve plan and start Phase 1
4. Create checkpoint after each phase
5. Review and iterate before next phase
Ready to proceed?
Step 10: Provide Iteration Guidance
After PRD delivery:
- How to use Plan Mode effectively
- When to create checkpoints
- How to handle deviations
Output Format
# [Product Name] PRD
## Quick Reference
| Attribute | Value |
|-----------|-------|
| Complexity | [Low/Medium/High] |
| Features | [Count] |
| Pages | [Count] |
| API Endpoints | [Count] |
| Phases | [Count] |
---
[Full PRD following template]
---
## Replit Agent Instructions
**Mode:** Start in Plan Mode
**Phase 1 Prompt:**
"Review this PRD and create a development plan for Phase 1: [Phase 1 Goal].
Don't start building yet - just outline your approach."
**Build Prompt (after plan approval):**
"Proceed with Phase 1 implementation. Create a checkpoint when complete."
**Subsequent Phases:**
Repeat plan → build → checkpoint cycle for each phase.
Rules
- ALWAYS include acceptance criteria — Every feature needs testable conditions
- ALWAYS define data model — Schema before code
- ALWAYS specify error handling — Every feature's error scenarios
- ALWAYS break into phases — 3-4 phases with clear checkpoints
- NEVER leave fields vague — Every input has type, constraints, validation
- NEVER skip security requirements — Always include security section
- PREFER reference apps — Concrete examples over abstract descriptions
Additional Resources
See reference files:
references/prd-examples.md— Complete PRD examples for different app types
Replit Prompt Generator
Transform requirements into optimized prompts for Replit Agent that maximize AI understanding and minimize iterations.
When to Use
- User wants to build something with Replit Agent
- User needs to convert an idea into a Replit-ready prompt
- User wants to improve an existing Replit prompt
- User is preparing to start a new Replit project
Core Principles (Replit's Official Guidelines)
1. Checkpoint — Structure Iteratively
Break large goals into smaller, testable steps. Use checkpoints between phases.
2. Debug — Provide Detailed Context
Include exact error messages, relevant code snippets, and steps already attempted.
3. Discover — Ask for Suggestions
Request tool/library recommendations when unsure about approach.
4. Experiment — Iterate on Prompts
Refine requests by adjusting wording or adding detail.
5. Instruct — Use Positive Goals
Frame as "do this" rather than "don't do that".
6. Select — Focused Context
Provide relevant context only; avoid overwhelming with unrelated information.
7. Show — Concrete Examples
Reduce ambiguity with code snippets, mockups, or reference apps.
8. Simplify — Concise Language
Use direct, short sentences. Avoid jargon.
9. Specify — Define Outputs
State expected outputs, constraints, data formats, and edge cases.
10. Test — Plan First
Outline features, data structures, and user flows before prompting.
Prompt Structure Template
When generating prompts for Replit, use this structure:
## Project Overview
[1-2 sentences: What is being built and its core purpose]
## Tech Stack
- Frontend: [specific framework/library]
- Backend: [specific framework/language]
- Database: [specific database]
- Authentication: [specific method]
- Additional: [any other required tools/APIs]
## Core Features
1. [Feature 1]: [specific description with expected behavior]
2. [Feature 2]: [specific description with expected behavior]
3. [Feature 3]: [specific description with expected behavior]
## UI/UX Requirements
- Design style: [modern/minimal/material/etc.]
- Color scheme: [specific colors or "neutral professional"]
- Layout: [sidebar/top-nav/dashboard/etc.]
- Responsive: [yes/no, breakpoints if specific]
## Data Model
[Describe main entities and their relationships]
- Entity1: field1, field2, field3
- Entity2: field1, field2 (relates to Entity1)
## User Flows
1. [Flow 1]: Step A → Step B → Step C → Result
2. [Flow 2]: Step A → Step B → Result
## Constraints
- [Constraint 1: e.g., "Must work offline"]
- [Constraint 2: e.g., "No external API calls except X"]
## Success Criteria
- [ ] [Specific testable criterion 1]
- [ ] [Specific testable criterion 2]
- [ ] [Specific testable criterion 3]
Procedure
Step 1: Gather Requirements
Ask the user about:
- What they want to build (core functionality)
- Who will use it (target users)
- How it should work (key user flows)
- Why (problem being solved)
If user provides vague input, ask clarifying questions:
- "What should happen when a user clicks X?"
- "Should data persist between sessions?"
- "Any specific design/framework preferences?"
Step 2: Extract Technical Details
Determine from user input or ask about:
- Preferred tech stack (or let Replit decide)
- Authentication requirements
- Data storage needs
- Third-party integrations
- Performance requirements
Step 3: Structure the Prompt
Transform gathered information into the structured template above.
Bad prompt transformation:
❌ Bad: "Make a website for my business"
✅ Good: "Create a portfolio website for a freelance photographer with:
- Home page with hero image carousel
- Gallery page with filterable photo categories
- Contact form with email integration
- About page with bio and testimonials
- Tech: React, TailwindCSS, EmailJS for form
- Design: Clean, minimal, lots of whitespace"
Step 4: Add Specificity
Enhance the prompt with:
- Concrete examples: "Like Stripe's dashboard layout"
- Specific behaviors: "Click 'Add' opens modal, not new page"
- Edge cases: "If cart is empty, show 'Start shopping' CTA"
- Validation rules: "Email must be valid format, password min 8 chars"
Step 5: Present Draft
Show the optimized prompt to the user:
## Replit Agent Prompt
**Optimized for:** [Build Mode / Plan Mode]
**Estimated complexity:** [Low / Medium / High]
---
[Generated prompt content]
---
**Recommendations:**
1. [Tip for using this prompt effectively]
2. [Suggested follow-up prompts after initial build]
Ready to copy to Replit?
Wait for user confirmation or modification requests.
Step 6: Provide Iteration Guidance
After delivering the prompt, advise on:
- Using Plan Mode first for complex features
- Setting up checkpoints between phases
- Follow-up prompts for refinements
Output Format
## Replit Agent Prompt
**Mode:** Build / Plan
**Complexity:** Low / Medium / High
---
[Structured prompt following template]
---
## Next Steps
1. **Initial Build**: Copy prompt to Replit Agent
2. **After MVP**: [Suggested enhancement prompt]
3. **Testing**: [What to verify after build]
## Checkpoint Strategy
Phase 1: [Description] → Checkpoint
Phase 2: [Description] → Checkpoint
Phase 3: [Description] → Checkpoint
Bad vs Good Prompt Examples
| Issue | Bad Prompt | Good Prompt |
|---|---|---|
| Vague | "Fix my code" | "The login function in auth.js throws 'undefined user' on line 42 when email contains '+'" |
| No scope | "Make a website" | "Create a 3-page portfolio: Home (hero, skills), Projects (grid with filters), Contact (form)" |
| Negative | "Don't make it slow" | "Implement lazy loading for images, paginate lists to 20 items" |
| No detail | "Add animation" | "Fade in hero text on page load over 0.5s, slide in cards from bottom on scroll" |
| Overwhelming | "Build the entire backend" | "Implement user signup/login with JWT and a /api/profile GET endpoint" |
Rules
- ALWAYS use positive framing — "Do X" not "Don't do Y"
- ALWAYS include tech stack — Even if "let Replit decide"
- ALWAYS define success criteria — Testable checkboxes
- ALWAYS break into phases — For anything beyond simple apps
- NEVER use vague terms — No "nice", "good", "fast", "modern" without specifics
- NEVER assume context — Replit Agent has no prior knowledge
Additional Resources
See reference files for detailed patterns:
references/examples.md— Full prompt examples for common app typesreferences/tech-stacks.md— Recommended tech stack combinations
Sponsors
Details
- Marketplace
- sergio-bershadsky/ai
- Source
- plugins/replit-prompts
- Category
- Productivity