Core Principles

1. Specification-First Approach

Begin every project with comprehensive requirements and technical specifications that serve as the "source of truth" for AI collaboration.

## Business Requirements
- What the system should accomplish
- Success criteria and constraints
- Target users and use cases

## Technical Architecture  
- System components and data flow
- Technology stack decisions
- Integration requirements

## Implementation Details
- API specifications
- Database schemas
- Security requirements

2. Progressive Decomposition

Break complex projects into manageable phases that AI can implement incrementally.

• Phase 1: Core infrastructure and foundations
• Phase 2: Data processing and storage
• Phase 3: Business logic and services
• Phase 4: User interfaces and integrations
• Phase 5: Testing, optimization, and deployment

3. Context-Rich Communication

Provide AI assistants with comprehensive context about your project, preferences, and constraints.

• Project specifications and requirements
• Code samples and patterns to follow
• Technology constraints and preferences
• Performance and cost requirements
• Integration needs and dependencies

The Prompt-Driven Development Workflow

Stage 1: Requirements Engineering with AI

Goal: Translate business needs into technical specifications through AI-assisted analysis.

1. Initial Concept Discussion: Present your project idea to the AI
2. Requirements Clarification: Allow AI to ask clarifying questions
3. Technical Architecture Design: Collaborate on system design
4. Specification Documentation: Create comprehensive technical specs

Human: "I want to build a chatbot for my educational website..."

AI: "Before we design the technical solution, let me understand:
- What type of questions should the chatbot handle?
- How should it integrate with your existing website?
- What are your cost and performance constraints?
- Do you need user authentication or session management?"

Stage 2: Project Structure and Setup

• Establish project directory structure
• Configure development tools and environments
• Create context files for AI reference
• Set up version control and documentation

Create a project structure for [project type] that includes:
- Clear separation of concerns
- Comprehensive documentation
- Context files for AI development
- Deployment automation scripts

Stage 3: Iterative Implementation

Interactive Prompting (Recommended for complex features):

I want to implement [feature]. Before coding, please ask me about:
- Architecture preferences and constraints
- Integration requirements
- Error handling strategies
- Performance considerations

Then implement the solution based on my responses.

Direct Prompting (For well-defined requirements):

Based on the specifications in @project-specs.md, implement:
- [Specific component or feature]
- Include comprehensive error handling
- Follow the patterns established in @existing-code
- Add appropriate tests and documentation

Best Practices for AI Collaboration

• Reference context files in your prompts
• Specify quality requirements (error handling, logging, tests)
• Request explanations for architectural decisions
• Iterate and refine based on feedback

Stage 4: Testing and Quality Assurance

• Generate comprehensive test suites
• Create performance benchmarks
• Build integration and end-to-end tests
• Develop monitoring and alerting systems

Create a comprehensive test suite for @user-service.py that includes:
- Unit tests for all public methods
- Integration tests for database operations
- Mock tests for external API calls
- Performance tests for critical paths

Stage 5: Deployment and Operations

• Infrastructure as code development
• Deployment automation scripts
• Monitoring and alerting setup
• Documentation and runbooks

AI Coding Assistants: Features & Best Practices

This guide highlights some of the features, configuration files, commands, and actionable tips for the leading AI coding assistants: Claude Code, GitHub Copilot, Cursor, Amazon Q Developer, and Cline. This is just a reference—the space is evolving rapidly, so always consult the official documentation of these assistants for the most up-to-date information.

Claude Code

• CLAUDE.md: Special file (repo root, subfolders, or ~/.claude/CLAUDE.md) automatically pulled into context. Best Practices & Examples
• Custom Slash Commands: Store prompt templates in .claude/commands/ and access via / in Claude.
• Safe YOLO Mode: Fewer permission prompts (allowlist or CLI flags).
• Headless Mode: Run Claude non-interactively for CI/automation (claude -p "prompt").
• Tool Allowlist: Control tool access via /allowed-tools, settings, or CLI flags.
• MCP Integration: Use .mcp.json for project-wide tool/server access.

• Use /clear to reset context between tasks.
• Use checklists and scratchpads (Markdown or GitHub issues) for complex workflows.
• Pipe data into Claude (cat file.txt | claude).
• Use multiple sessions or worktrees for parallel tasks and code review.
• Iterate on your CLAUDE.md for best results.

GitHub Copilot

• .github/copilot-instructions.md: Project-level custom instructions for Copilot Chat and coding agent. How to use
• Prompt Files: Store reusable prompt instructions in .github/prompts/ (public preview).
• Copilot Chat: Conversational AI for code explanations, debugging, and learning APIs.
• Copilot CLI: Shell command suggestions and explanations.
• Pull Request Support: PR descriptions, code reviews, and explanations.

• Reference files and style guides in .github/copilot-instructions.md for consistency.
• Use prompt files for complex, repeatable instructions.
• Always review and edit generated code.
• Leverage test generation, but validate coverage and correctness.
• Keep your codebase clean and well-documented.

Cursor

• .cursorrules.md: Project-level rules for coding standards and workflow.
• Slash Commands: /explain, /test, etc., for quick actions.
• MCP Integration: Connect to external data, live docs, and more.
• Project Templates: Start new projects with AI-powered templates.

• Use @cursorrules for project standards.
• Reference files/functions in chat for precise help.
• Use MCP for live data/external context.
• Try / commands for quick actions.
• Use project templates for fast setup.

Amazon Q Developer

• AWS Context: Deep integration with AWS services and resources.
• Security Analysis: Automated code security and compliance checks.
• Infrastructure as Code: Generate and explain CloudFormation, CDK, and Terraform templates.
• CLI Integration: Amazon Q CLI for command-line productivity and automation.
• No project-level config file: Context managed via AWS project settings and credentials.

• Use Q for generating and explaining AWS infrastructure code.
• Leverage security analysis for compliance and best practices.
• Use the CLI for automating repetitive AWS tasks.
• Provide clear AWS context (region, service, resource names) for best results.
• Always review generated infrastructure code for security and cost implications.

Cline

• .clinerules/ directory: Place Markdown files with coding standards, documentation requirements, and workflow rules here. Cline Rules Guide
• .clineignore: Exclude files and folders from Cline's context (like .gitignore). Prompt Engineering Guide
• Custom Slash Commands: Store prompt templates and workflows in .clinerules/ or use slash commands in chat.
• Plan & Act: Structured, multi-step planning and execution for complex tasks. Plan & Act
• @ Mentions: Reference files, folders, or people in prompts for precise context. @ Mentions
• Workflows: Automate multi-step coding or project tasks. Workflows
• MCP Servers: Integrate with external databases, live docs, and more via MCP protocol. MCP Overview
• Memory Bank: Persistent memory for context and project knowledge. Memory Bank
• Drag & Drop: Drag files into chat for context or analysis.
• Checkpoints: Save and restore project states during development.
• Auto Approve: Automatically approve certain actions for faster workflows.

• Use @-mentions for precise context in prompts.
• Store standards and rules in .clinerules/ for team-wide consistency.
• Use Plan & Act for breaking down and executing complex tasks.
• Integrate MCP for external data and live documentation.
• Use drag & drop for quick context sharing.
• Try checkpoints for safe experimentation and easy rollback.
• Regularly update .clineignore to keep context relevant and secure.

General Tips for All AI Coding Assistants

• Give URLs to fetch: Many assistants can fetch and analyze content from URLs.
• Give images: Some can analyze images if provided.
• Mention/reference files in prompts: Use file names, or copy and paste code or docs into your prompt for best results.
• Clear context/start over: Use commands like /clear or start a new chat to reset the assistant's context.
• Use checklists and scratchpads: For complex workflows, have the assistant use a Markdown file or issue as a checklist and working scratchpad.
• Break down large tasks: Divide complex requests into smaller, focused prompts for better results.
• Iterate and refine: Review, test, and refine the assistant's output—don't expect perfection on the first try.

Case Study: Educational Chatbot

Initial Requirements Gathering

"I want to create a chatbot for my course website that helps students navigate course content."

• Content scope and question types
• Integration requirements
• Performance and cost constraints
• User experience expectations

Collaborative Specification Development

• Business Requirements: Student support, content navigation, reference recommendations
• Technical Architecture: Vector database, LLM integration, popup widget
• Implementation Plan: Phase-by-phase development approach
• Success Criteria: Response accuracy, performance, cost control

Prompt Strategy Development

We create two types of prompts for each development phase:

Interactive Prompts for complex decisions:

I want to set up the infrastructure. Before implementing, ask me about:
- Cloud provider preferences
- Cost optimization strategies  
- Security requirements
- Monitoring needs

Direct Prompts for clear requirements:

Based on @specifications.md, create the vector database service that:
- Stores course content embeddings
- Performs similarity search
- Handles concurrent queries
- Includes proper error handling

Incremental Development

1. Infrastructure: Database, APIs, monitoring
2. Data Processing: Content extraction, embeddings
3. Core Services: Search, session management, LLM integration
4. User Interface: Chat widget, responsive design
5. Deployment: Automation, monitoring, maintenance

Best Practices for Prompt-Driven Development

1. Start with Clear Context
   • Always provide comprehensive project specifications
   • Reference existing code and patterns
   • Explain constraints and preferences
   • Share relevant documentation
2. Use Iterative Refinement
   • Build and test incrementally
   • Refine requirements based on AI feedback
   • Validate assumptions through implementation
   • Adjust specifications as you learn
3. Maintain Quality Standards
   • Request comprehensive error handling
   • Ask for testing and documentation
   • Specify performance requirements
   • Require security best practices
4. Leverage AI Strengths
   • Use AI for boilerplate and infrastructure code
   • Get architectural guidance and best practices
   • Generate comprehensive test suites
   • Create documentation and deployment scripts
5. Understand AI Limitations
   • Verify complex business logic
   • Test edge cases thoroughly
   • Review security implementations
   • Validate performance characteristics

Common Pitfalls and Solutions

Pitfall 1: Vague Requirements

Problem: AI generates code that doesn't meet your needs

Solution: Provide detailed specifications and context

Pitfall 2: Monolithic Requests

Problem: Asking for entire systems at once

Solution: Break requests into manageable components

Pitfall 3: Ignoring Quality Requirements

Problem: Generated code lacks error handling or tests

Solution: Always specify quality and testing requirements

Pitfall 4: Poor Context Management

Problem: AI loses track of project requirements

Solution: Use context files and reference previous work

Capstone Project: Store Intelligence Assistant

Project Overview

Your capstone project involves building a Store Intelligence Assistant - a conversational AI agent that helps regional managers analyze store performance, lookup policies, and access operational information across multiple retail locations.

Business Scenario

• Your Role: Regional Manager overseeing 8 grocery stores
• The Challenge: You need quick access to store performance data, operational policies, and lease information to make informed decisions
• The Solution: An AI assistant that can query data, search documents, and maintain conversation context

Core Capabilities

1. Store Performance Analysis
   • How did Store 3 perform last week?
   • Which store had the highest sales growth this month?
   • Compare dairy sales across all stores for the past 30 days
   • What's the average sales per square foot for downtown stores?
2. Policy and Procedure Lookups
   • What's our damaged goods policy?
   • How do we handle customer complaints about expired products?
   • What are the procedures for inventory discrepancies?
   • What's the policy on employee scheduling conflicts?
3. Lease and Operational Information
   • When does the downtown lease expire?
   • Which stores have leases expiring in the next 6 months?
   • What's the square footage of Store 5?
   • Who manages the suburban location?

Technical Requirements

• Multi-turn Conversation: Maintain context across multiple exchanges
• Tool Integration: Orchestrate between data queries and document search
• Memory Management: Remember previous interactions and user preferences
• Decision Logic: Choose appropriate tools based on query type

Core Components

1. Data Query Tool: Execute structured queries on CSV data with aggregations
2. Document Search Tool: Perform semantic search across PDF documents
3. Memory System: Store and retrieve conversation history and context
4. Decision Engine: Coordinate tool usage and response generation

Provided Datasets

• stores.csv: Store directory (8 stores)
• sales_data.csv: Historical sales performance (~2,000 records)
• store_policy_manual.pdf: Operational procedures (8 pages)
• lease_[store_name].pdf: Individual lease agreements (8 files, 6 pages each)

Implementation Phases

1. Foundation (Week 1): Setup, data analysis, architecture, specs
2. Tool Development (Week 2): Data query, document search, interface, error handling
3. Agent Integration (Week 3): Memory, decision logic, orchestration, interface
4. Enhancement & Deployment (Week 4): Advanced features, error handling, deployment, monitoring

Success Criteria

• Functional: Accurate answers, context retention, ambiguity handling
• Technical: Clean code, error handling, orchestration, memory, deployment
• User Experience: Conversational style, response time, clarity, suggestions, professionalism

Technology Flexibility

• AI/LLM Services: AWS Bedrock, Azure OpenAI, Google Vertex AI, OpenAI API, or self-hosted models
• Development Environment: Cursor, VS Code, PyCharm, or your preferred IDE
• Cloud Platform: AWS, Azure, Google Cloud, or local deployment
• Programming Language: Python, JavaScript/Node.js, Java, or others
• Database: Vector databases, traditional SQL, or in-memory solutions

Learning Outcomes

1. End-to-End AI Application Development
2. Agent Architecture Design
3. Prompt-Driven Development
4. Production Considerations
5. Business Application

Getting Started

1. Choose your technology stack
2. Analyze the data
3. Apply prompt-driven methodology
4. Document your process

Additional Resources

AI-Powered Development Tools

• Amazon Q Developer: Amazon Q CLI User Guide
• Cline (formerly Claude Dev): Cline - Autonomous Coding Agent
• Cursor IDE: Cursor.sh
• GitHub Copilot: GitHub Copilot Docs
• Claude Code (Anthropic): Introducing Claude Code

Prompt-Driven Development Resources

• The AI-First Developer
• Vibe-Based Programming
• Prompt Engineering for Developers

Community Resources

• r/ChatGPTCoding
• AI Coding Discord
• Stack Overflow: AI-Assisted Development Tag

Learning Materials

• Building with AI Course
• The Prompt Engineer's Handbook
• AI Jason - Cursor Tutorials
• The AI Advantage - Coding with AI
• Fireship - AI Development

Development Workflow Templates

• Cursor Project Templates
• GitHub Copilot Workspaces
• AI-First Project Structure

Prompt Libraries

• Awesome ChatGPT Prompts
• Engineering Prompts
• Code Generation Prompts

Evaluation and Quality Tools

• Sourcery
• Codiga
• SonarQube

Testing with AI

• Test Generation
• Automated QA
• Performance Testing

Industry Insights

• GitHub Copilot Study
• AI Coding Survey
• Anthropic Research
• Effective AI Pair Programming
• The Future of Software Development
• Prompt-Driven Development at Scale