appiq-solution 1.2.0 → 1.3.1

package/{bmad-core → #Tools/APPIQ-METHOD/bmad-core}/user-guide.md

@@ -1,12 +1,12 @@
 # BMad-Method BMAd Code User Guide
 
-This guide will help you understand and effectively use the BMad Method for agile AI driven planning and development.
+This guide will help you understand and effectively use the BMad Method for agile ai driven planning and development.
 
 ## The BMad Plan and Execute Workflow
 
-First, here is the full standard Greenfield Planning + Execution Workflow. Brownfield is very similar, but it's suggested to understand this greenfield first, even if on a simple project before tackling a brownfield project. The BMad Method needs to be installed to the root of your new project folder. For the planning phase, you can optionally perform it with powerful web agents, potentially resulting in higher quality results at a fraction of the cost it would take to complete if providing your own API key or credits in some Agentic tools. For planning, powerful thinking models and larger context - along with working as a partner with the agents will net the best results.
+First, here is the full standard Greenfield Planning + Execution Workflow. Brownfield is very similar, but its suggested to understand this greenfield first, even if on a simple project before tackling a brownfield project. The BMad Method needs to be installed to the root of your new project folder. For the planning phase, you can optionally perform it with powerful web agents, potentially resulting in higher quality results at a fraction of the cost it would take to complete if providing your own API key or credits in some Agentic tools. For planning, powerful thinking models and larger context - along with working as a partner with the agents will net the best results.
 
-If you are going to use the BMad Method with a Brownfield project (an existing project), review **[Working in the Brownfield](./working-in-the-brownfield.md)**.
+If you are going to use the BMad Method with a Brownfield project (an existing project), review [Working in the Brownfield](./working-in-the-brownfield.md)
 
 If you do not see the diagrams that following rendering, you can install Markdown All in One along with the Markdown Preview Mermaid Support plugins to VSCode (or one of the forked clones). With these plugin's, if you right click on the tab when open, there should be a Open Preview option, or check the IDE documentation.
 
@@ -85,9 +85,9 @@ Once planning is complete and documents are sharded, BMad follows a structured d
 graph TD
     A["Development Phase Start"] --> B["SM: Reviews Previous Story Dev/QA Notes"]
     B --> B2["SM: Drafts Next Story from Sharded Epic + Architecture"]
-    B2 --> B3{"PO: Validate Story Draft (Optional)"}
-    B3 -->|Validation Requested| B4["PO: Validate Story Against Artifacts"]
-    B3 -->|Skip Validation| C{"User Approval"}
+    B2 --> B3{"QA: Review Story Draft (Optional)"}
+    B3 -->|Review Requested| B4["QA: Review Story Against Artifacts"]
+    B3 -->|Skip Review| C{"User Approval"}
     B4 --> C
     C -->|Approved| D["Dev: Sequential Task Execution"]
     C -->|Needs Changes| B2
@@ -132,7 +132,7 @@ graph TD
 If you want to do the planning in the Web with Claude (Sonnet 4 or Opus), Gemini Gem (2.5 Pro), or Custom GPT's:
 
 1. Navigate to `dist/teams/`
-2. Copy `team-fullstack.txt`
+2. Copy `team-fullstack.txt` content
 3. Create new Gemini Gem or CustomGPT
 4. Upload file with instructions: "Your critical operating instructions are attached, do not break character as directed"
 5. Type `/help` to see available commands
@@ -152,7 +152,7 @@ There are two bmad agents - in the future they will be consolidated into the sin
 
 This agent can do any task or command that all other agents can do, aside from actual story implementation. Additionally, this agent can help explain the BMad Method when in the web by accessing the knowledge base and explaining anything to you about the process.
 
-If you don't want to bother switching between different agents aside from the dev, this is the agent for you. Just remember that as the context grows, the performance of the agent degrades, therefore it is important to instruct the agent to compact the conversation and start a new conversation with the compacted conversation as the initial message. Do this often, preferably after each story is implemented.
+If you dont want to bother switching between different agents aside from the dev, this is the agent for you.
 
 ### BMad-Orchestrator
 
@@ -210,7 +210,6 @@ dependencies:
 - **Agent Selection**: Use appropriate agent for task
 - **Iterative Development**: Work in small, focused tasks
 - **File Organization**: Maintain clean project structure
-- **Commit Regularly**: Save your work frequently
 
 ## Technical Preferences System
 
@@ -237,7 +236,7 @@ devLoadAlwaysFiles:
 
 You will want to verify from sharding your architecture that these documents exist, that they are as lean as possible, and contain exactly the information you want your dev agent to ALWAYS load into it's context. These are the rules the agent will follow.
 
-As your project grows and the code starts to build consistent patterns, coding standards should be reduced to include only the standards that the agent still makes with. The agent will look at surrounding code in files to infer the coding standards that are relevant to the current task.
+As your project grows and the code starts to build consistent patterns, coding standards should be reduced to just the items that the agent makes mistakes at still - must with the better models, they will look at surrounding code in files and not need a rule from that file to guide them.
 
 ## Getting Help
 

package/{bmad-core → #Tools/APPIQ-METHOD/bmad-core}/working-in-the-brownfield.md

@@ -2,10 +2,10 @@
 
 > **HIGHLY RECOMMENDED: Use Gemini Web or Gemini CLI for Brownfield Documentation Generation!**
 >
-> Gemini Web's 1M+ token context window or Gemini CLI (when it's working) can analyze your ENTIRE codebase, or critical sections of it, all at once (obviously within reason):
+> Gemini Web's 1M+ token context window or Gemini CLI (when its working) can analyze your ENTIRE codebase or critical sections of it all at once (obviously within reason):
 >
 > - Upload via GitHub URL or use gemini cli in the project folder
-> - If working in the web: use `npx bmad-method flatten` to flatten your project into a single file, then upload that file to your web agent.
+> - If in the web: Upload up to 1000 files or the zipped project or just give it the github url
 
 ## What is Brownfield Development?
 
@@ -22,13 +22,10 @@ Brownfield development refers to adding features, fixing bugs, or modernizing ex
 
 ## When NOT to use a Brownfield Flow
 
-If you have just completed an MVP with BMad, and you want to continue with post-MVP, its easier to just talk to the PM and ask it to work with you to create a new epic to add into the PRD, shard out the epic, update any architecture documents with the architect, and just go from there.
+If you have just completed an MVP with BMad, and you want to continue with post-MVP, its easier to just talk to the PM and ask him to work with you to create a new epic to add into the PRD, shard out the epic, update any architecture documents with the architect, and just go from there.
 
 ## The Complete Brownfield Workflow
 
-1. **Follow the [<ins>User Guide - Installation</ins>](user-guide.md#installation) steps to setup your agent in the web.**
-2. **Generate a 'flattened' single file of your entire codebase** run: ```npx bmad-method flatten```
-
 ### Choose Your Approach
 
 #### Approach A: PRD-First (Recommended if adding very large and complex new features, single or multiple epics or massive changes)
@@ -51,11 +48,11 @@ If you have just completed an MVP with BMad, and you want to continue with post-
 
 #### Phase 1: Define Requirements First
 
-**In Gemini Web (with your flattened-codebase.xml uploaded):**
+**In Gemini Web (with your codebase uploaded):**
 
 ```bash
 @pm
-*create-brownfield-prd
+*create-doc brownfield-prd
 ```
 
 The PM will:
@@ -72,7 +69,7 @@ The PM will:
 **Still in Gemini Web, now with PRD context:**
 
 ```bash
-@architect
+@analyst
 *document-project
 ```
 
@@ -107,21 +104,22 @@ For example, if you say "Add payment processing to user service":
 1. **Go to Gemini Web** (gemini.google.com)
 2. **Upload your project**:
    - **Option A**: Paste your GitHub repository URL directly
-   - **Option B**: Upload your flattened-codebase.xml file
-3. **Load the analyst agent**: Upload `dist/agents/architect.txt`
+   - **Option B**: Upload up to 1000 files from your src/project folder
+   - **Option C**: Zip your project and upload the archive
+3. **Load the analyst agent**: Upload `dist/agents/analyst.txt`
 4. **Run documentation**: Type `*document-project`
 
 The analyst will generate comprehensive documentation of everything.
 
 #### Phase 2: Plan Your Enhancement
 
-##### Option A: Full Brownfield Workflow (Recommended for Major Changes)
+#### Option A: Full Brownfield Workflow (Recommended for Major Changes)
 
 **1. Create Brownfield PRD**:
 
 ```bash
 @pm
-*create-brownfield-prd
+*create-doc brownfield-prd
 ```
 
 The PM agent will:
@@ -148,7 +146,7 @@ The PM agent will:
 
 ```bash
 @architect
-*create-brownfield-architecture
+*create-doc brownfield-architecture
 ```
 
 The architect will:
@@ -159,13 +157,13 @@ The architect will:
 - **Identify technical risks**
 - **Define compatibility requirements**
 
-##### Option B: Quick Enhancement (For Focused Changes)
+#### Option B: Quick Enhancement (For Focused Changes)
 
 **For Single Epic Without Full PRD**:
 
 ```bash
 @pm
-*create-brownfield-epic
+*brownfield-create-epic
 ```
 
 Use when:
@@ -179,7 +177,7 @@ Use when:
 
 ```bash
 @pm
-*create-brownfield-story
+*brownfield-create-story
 ```
 
 Use when:
@@ -193,7 +191,7 @@ Use when:
 
 ```bash
 @po
-*execute-checklist-po
+*execute-checklist po-master-checklist
 ```
 
 The PO ensures:
@@ -203,27 +201,26 @@ The PO ensures:
 - Risk mitigation strategies in place
 - Clear integration approach
 
-### Phase 4: Save and Shard Documents
+### Phase 4: Transition to Development
 
-1. Save your PRD and Architecture as:
-   docs/brownfield-prd.md
-   docs/brownfield-architecture.md
-2. Shard your docs:
-   In your IDE
+Follow the enhanced IDE Development Workflow:
 
-   ```bash
-   @po
-   shard docs/brownfield-prd.md
-   ```
+1. **Ensure documents are in project**:
+
+   - Copy `docs/prd.md` (or brownfield-prd.md)
+   - Copy `docs/architecture.md` (or brownfield-architecture.md)
+
+2. **Shard documents**:
 
    ```bash
    @po
-   shard docs/brownfield-architecture.md
+   # Ask to shard docs/prd.md
    ```
 
-### Phase 5: Transition to Development
-
-**Follow the [<ins>Enhanced IDE Development Workflow</ins>](enhanced-ide-development-workflow.md)**
+3. **Development cycle**:
+   - **SM** creates stories with integration awareness
+   - **Dev** implements with existing code respect
+   - **QA** reviews for compatibility and improvements
 
 ## Brownfield Best Practices
 
@@ -290,7 +287,7 @@ Document:
 ### Scenario 3: Bug Fix in Complex System
 
 1. Document relevant subsystems
-2. Use `create-brownfield-story` for focused fix
+2. Use `brownfield-create-story` for focused fix
 3. Include regression test requirements
 4. QA validates no side effects
 
@@ -313,7 +310,7 @@ Document:
 
 ### "Too much boilerplate for small changes"
 
-**Solution**: Use `create-brownfield-story` instead of full workflow
+**Solution**: Use `brownfield-create-story` instead of full workflow
 
 ### "Integration points unclear"
 
@@ -325,19 +322,19 @@ Document:
 
 ```bash
 # Document existing project
-@architect → *document-project
+@analyst → *document-project
 
 # Create enhancement PRD
-@pm → *create-brownfield-prd
+@pm → *create-doc brownfield-prd
 
 # Create architecture with integration focus
-@architect → *create-brownfield-architecture
+@architect → *create-doc brownfield-architecture
 
 # Quick epic creation
-@pm → *create-brownfield-epic
+@pm → *brownfield-create-epic
 
 # Single story creation
-@pm → *create-brownfield-story
+@pm → *brownfield-create-story
 ```
 
 ### Decision Tree

package/#Tools/APPIQ-METHOD/deployment/DEPLOYMENT_GUIDE.md

@@ -0,0 +1,426 @@
+# 🚀 APPIQ Method - Complete Deployment Guide
+
+## Overview
+
+The APPIQ Method deployment system allows you to package and distribute the complete mobile development workflow system as a single, self-contained installer.
+
+## 📦 Deployment Files Created
+
+### Core Installation Scripts
+
+1. **`appiq_installer.sh`** - Single-file installer with embedded components
+   - Self-contained with all necessary files
+   - No external dependencies
+   - Works offline after download
+   - Size: ~1MB
+
+2. **`init_appiq.sh`** - Development installer (requires git/network)
+   - Downloads latest files from repository
+   - Development version with full features
+   - Requires internet connection
+
+3. **`quick-install.sh`** - One-command installer
+   - Downloads and runs installer automatically
+   - Simplest user experience
+   - Requires curl/wget
+
+### Build Scripts
+
+4. **`package.sh`** - Creates the single-file installer
+5. **`build-release.sh`** - Creates complete release package
+6. **`test-install.sh`** - Tests installation in temporary directory
+
+## 🎯 Usage Scenarios
+
+### For End Users (Project Setup)
+
+#### Scenario 1: One-Command Install (Recommended)
+```bash
+# Navigate to your project folder
+cd my-mobile-app
+
+# Install APPIQ Method
+curl -fsSL https://raw.githubusercontent.com/Viktor-Hermann/APPIQ-METHOD/main/deployment/quick-install.sh | bash
+
+# Customize PRD and start development
+nano docs/main_prd.md
+# Then use /appiq in your IDE
+```
+
+#### Scenario 2: Download and Run
+```bash
+# Download the installer
+wget https://github.com/Viktor-Hermann/APPIQ-METHOD/releases/latest/download/appiq_installer.sh
+
+# Run in your project
+cd my-project
+bash appiq_installer.sh
+```
+
+#### Scenario 3: Offline Installation
+```bash
+# Copy appiq_installer.sh to project folder (via USB, network share, etc.)
+cp /path/to/appiq_installer.sh ./
+bash appiq_installer.sh
+```
+
+### For Developers (Creating Packages)
+
+#### Build Single-File Installer
+```bash
+cd deployment
+bash package.sh
+
+# Output: dist/appiq_installer.sh (ready to distribute)
+```
+
+#### Build Complete Release
+```bash
+cd deployment  
+bash build-release.sh
+
+# Output: Complete release package with documentation
+```
+
+#### Test Installation
+```bash
+# Create test directory
+mkdir /tmp/test-appiq && cd /tmp/test-appiq
+
+# Test installation
+bash /path/to/appiq_installer.sh
+
+# Validate installation
+./.appiq/scripts/appiq validate
+```
+
+## 📁 What Gets Installed
+
+### Directory Structure Created
+```
+your-project/
+├── .appiq/                           # APPIQ Method core
+│   ├── agents/                       # Mobile development agents
+│   │   ├── mobile-pm.md
+│   │   ├── mobile-architect.md
+│   │   ├── mobile-developer.md
+│   │   ├── mobile-qa.md
+│   │   ├── mobile-security.md
+│   │   ├── mobile-analytics.md
+│   │   └── mobile-ux-expert.md
+│   ├── workflows/                    # Mobile workflows
+│   │   ├── mobile-greenfield-flutter.yaml
+│   │   ├── mobile-greenfield-react-native.yaml
+│   │   ├── mobile-brownfield-flutter.yaml
+│   │   └── mobile-brownfield-react-native.yaml
+│   ├── templates/                    # Document templates
+│   │   ├── mobile-prd-tmpl.yaml
+│   │   ├── mobile-architecture-tmpl.yaml
+│   │   └── mobile-story-tmpl.yaml
+│   ├── checklists/                   # Validation checklists
+│   │   └── mobile-development-checklist.md
+│   ├── teams/                        # Team configurations
+│   │   ├── mobile-team-flutter.yaml
+│   │   ├── mobile-team-react-native.yaml
+│   │   └── mobile-team-cross-platform.yaml
+│   ├── config/                       # IDE configurations
+│   │   ├── project.json
+│   │   ├── claude.json
+│   │   ├── cursor.json
+│   │   └── windsurf.json
+│   ├── scripts/                      # Helper utilities
+│   │   └── appiq                     # Status/validation tool
+│   └── README.md                     # Local documentation
+├── docs/                             # Project documentation
+│   └── main_prd.md                   # PRD template (customize!)
+└── README.md                         # Updated with APPIQ section
+```
+
+### Key Components Installed
+- **8 Mobile Agents**: Specialized for mobile development
+- **4 Workflows**: Greenfield/Brownfield × Flutter/React Native
+- **Multiple Templates**: PRD, Architecture, Story templates
+- **Comprehensive Checklist**: Mobile development validation
+- **Team Configurations**: Pre-configured mobile teams
+- **IDE Integration**: Claude, Cursor, Windsurf configurations
+- **Helper Scripts**: Project status and validation tools
+
+## 🔧 Post-Installation
+
+### 1. Customize Your PRD
+The installer creates `docs/main_prd.md` with a template. Customize it:
+
+```markdown
+# Main Product Requirements Document
+
+## Project Overview
+**Project Name:** Your Actual App Name
+**Platform:** [x] iOS [x] Android [ ] Cross-platform
+
+## Core Features
+### Epic 1: Authentication
+- [ ] User registration with email
+- [ ] Social login (Google, Apple)
+- [ ] Password reset functionality
+
+### Epic 2: Core Features
+- [ ] [Your main feature]
+- [ ] [Secondary feature]
+- [ ] [Additional feature]
+
+## Technical Requirements
+- **Framework:** Flutter  # or React Native
+- **State Management:** BLoC  # or Riverpod, Redux, etc.
+- **Backend:** Firebase  # or your backend
+- **Performance:** App launch < 3 seconds
+```
+
+### 2. Start Development Workflow
+Open your IDE and use the `/appiq` command:
+
+**Claude Code:**
+```
+/appiq
+```
+
+**Cursor:**
+```
+/appiq
+# or press Ctrl+Alt+A (Cmd+Alt+A on Mac)
+```
+
+**Windsurf:**
+```
+/appiq
+```
+
+### 3. Follow Interactive Flow
+The system guides you through:
+1. **Project Type**: Greenfield (new) or Brownfield (existing)
+2. **Platform**: Flutter or React Native  
+3. **PRD Validation**: Checks your customized PRD
+4. **Workflow Launch**: Automatically starts appropriate workflow
+
+### 4. Validate Installation
+```bash
+# Check status
+./.appiq/scripts/appiq status
+
+# Validate setup
+./.appiq/scripts/appiq validate
+
+# View help
+./.appiq/scripts/appiq help
+```
+
+## 🎨 IDE Integration Details
+
+### Claude Code
+- **Native Support**: `/appiq` command recognized natively
+- **Context Aware**: Understands project structure automatically
+- **File Integration**: Can read/write project files directly
+
+### Cursor
+- **Chat Command**: Use `/appiq` in chat interface
+- **Command Palette**: "APPIQ: Launch Mobile Workflow"
+- **Keyboard Shortcut**: `Ctrl+Alt+A` (customizable)
+- **Workspace Settings**: Automatic .vscode/settings.json configuration
+
+### Windsurf
+- **AI Analysis**: Automatically analyzes project structure
+- **Smart Detection**: Detects Flutter/React Native automatically
+- **Task Integration**: Creates task tracking for workflow steps
+- **Project Context**: Maintains context across sessions
+
+### Universal (Any IDE)
+- **Chat Interface**: Works with any IDE supporting chat
+- **Fallback Mode**: Asks user for information when auto-detection fails
+- **Manual Guidance**: Provides step-by-step instructions
+
+## 🔄 Updates and Maintenance
+
+### Update APPIQ Method
+```bash
+# Using helper script
+./.appiq/scripts/appiq update
+
+# Or re-run installer
+bash appiq_installer.sh --update
+
+# Or manual download
+curl -fsSL https://raw.githubusercontent.com/Viktor-Hermann/APPIQ-METHOD/main/deployment/quick-install.sh | bash
+```
+
+### Check for Updates
+```bash
+# Compare versions
+./.appiq/scripts/appiq status
+cat .appiq/config/project.json | grep appiq_version
+```
+
+### Backup Configuration
+```bash
+# Backup your customizations
+cp docs/main_prd.md docs/main_prd.backup.md
+cp -r .appiq/config .appiq/config.backup
+```
+
+## 🚨 Troubleshooting
+
+### Common Issues and Solutions
+
+#### Issue: "Command /appiq not recognized"
+```bash
+# Check installation
+./.appiq/scripts/appiq validate
+
+# Verify IDE configuration
+ls .appiq/config/
+
+# Restart IDE and try again
+```
+
+#### Issue: "main_prd.md not found"
+```bash
+# Create the file
+touch docs/main_prd.md
+
+# Or re-run installer to recreate template
+bash appiq_installer.sh
+```
+
+#### Issue: "Platform detection failed"
+```bash
+# Check project structure
+ls -la
+
+# For Flutter: Look for pubspec.yaml
+# For React Native: Look for package.json with react-native dependency
+
+# Manually specify platform when prompted
+```
+
+#### Issue: "Workflow launch failed"
+```bash
+# Validate all components
+./.appiq/scripts/appiq validate
+
+# Check workflow files
+ls .appiq/workflows/
+
+# Re-run installer if files are missing
+bash appiq_installer.sh --update
+```
+
+### Debug Mode
+```bash
+# Enable verbose logging
+export APPIQ_DEBUG=true
+
+# Run status check with debug info
+./.appiq/scripts/appiq status
+
+# Check installation details
+cat .appiq/config/project.json
+```
+
+### Reset Installation
+```bash
+# Complete reset (removes all APPIQ files)
+rm -rf .appiq docs/main_prd.md
+
+# Reinstall
+bash appiq_installer.sh
+```
+
+## 📊 System Requirements
+
+### Minimum Requirements
+- **OS**: Linux, macOS, or Windows with WSL
+- **Disk Space**: 10MB for installation
+- **Dependencies**: Bash shell
+- **Optional**: Git (for enhanced features)
+
+### Recommended Setup
+- **Mobile SDK**: Flutter SDK or React Native environment
+- **IDE**: Claude Code, Cursor, or Windsurf
+- **Project**: Git repository
+- **Network**: Internet connection for initial download
+
+### Supported Project Types
+- ✅ Flutter projects (pubspec.yaml)
+- ✅ React Native projects (package.json + react-native)
+- ✅ New mobile projects (any directory)
+- ✅ Existing mobile projects
+- ⚠️ Other project types (basic support)
+
+## 🎯 Success Metrics
+
+### Installation Success Indicators
+- ✅ `.appiq/` directory created with all components
+- ✅ `docs/main_prd.md` exists (customizable template)
+- ✅ Helper script works: `./.appiq/scripts/appiq status`
+- ✅ Validation passes: `./.appiq/scripts/appiq validate`
+- ✅ IDE recognizes `/appiq` command
+
+### Development Workflow Success
+- ✅ `/appiq` command starts interactive flow
+- ✅ Platform detection works correctly
+- ✅ PRD validation passes
+- ✅ Appropriate workflow launches automatically
+- ✅ First agent (@analyst) starts project brief creation
+
+### Quality Indicators
+- ✅ All agents respond correctly to @mentions
+- ✅ Generated documents save to docs/ folder
+- ✅ Workflow progression follows expected sequence
+- ✅ Mobile-specific templates and checklists used
+- ✅ Platform-specific guidance provided
+
+## 📈 Distribution Strategy
+
+### Release Process
+1. **Build Package**: `bash build-release.sh`
+2. **Test Installation**: Test in clean environment
+3. **Create GitHub Release**: Upload to releases
+4. **Update URLs**: Update download links in quick-install.sh
+5. **Documentation**: Update README and installation guides
+
+### Distribution Channels
+- **GitHub Releases**: Primary distribution method
+- **Direct Download**: For offline environments
+- **Package Managers**: Future NPM/Homebrew packages
+- **Documentation Sites**: Embedded installation guides
+
+### Versioning
+- **Semantic Versioning**: MAJOR.MINOR.PATCH
+- **Release Notes**: Detailed changelog for each version
+- **Compatibility**: Backward compatibility for configurations
+- **Migration Guides**: When breaking changes occur
+
+---
+
+## 🎉 Conclusion
+
+The APPIQ Method deployment system provides a complete, self-contained mobile development workflow that can be installed in any project with a single command. The system includes:
+
+- **Complete Mobile Development Stack**: Agents, workflows, templates, checklists
+- **Universal IDE Integration**: Works with Claude, Cursor, Windsurf, and others
+- **Interactive Setup**: `/appiq` command for guided workflow selection  
+- **Offline Capability**: Self-contained installer works without internet
+- **Validation Tools**: Built-in status checking and problem diagnosis
+- **Update Mechanism**: Easy updates while preserving customizations
+
+### Quick Start Summary
+```bash
+# 1. Install in your project
+curl -fsSL https://raw.githubusercontent.com/Viktor-Hermann/APPIQ-METHOD/main/deployment/quick-install.sh | bash
+
+# 2. Customize your requirements
+nano docs/main_prd.md
+
+# 3. Start development
+# Open IDE and use: /appiq
+```
+
+The system is now ready for production use and can be distributed to development teams for immediate mobile development workflow automation!