Skip to main content
The quality of your results depends heavily on how clearly and effectively you communicate your intentions. Good prompting is a skill that combines clarity, specificity, and understanding of how AI models process information.

​
Understanding AI Communication

AI models process your requests through text, so the way you phrase your questions and instructions directly impacts the quality of responses. Effective prompting involves:
  • Clarity: Being specific about what you want
  • Context: Providing necessary background information
  • Structure: Organizing your requests logically
  • Iteration: Refining your approach based on responses

​
Example Prompts

CodinIT provides curated example prompts to help you get started:

Web Development

“Create a modern React dashboard with charts and data visualization”

Mobile Apps

“Build a React Native expense tracker with offline storage”

APIs & Backend

“Create a REST API for a blog with authentication and comments”

Full Stack

“Build a task management app with React frontend and Node.js backend”
These examples demonstrate effective prompting patterns that you can adapt to your specific needs.

​
Core Prompting Principles

​
Be Specific and Structured

Clear Intent: 
❌ "Make this look better"
✅ "Add a gradient background from blue to purple, increase font size to 24px, and add 16px padding around the hero section"
Provide Context: 
❌ "Add error handling"
✅ "Add error handling to the login form - show validation messages for empty email/password fields and API errors"
Break Down Complex Tasks: 
❌ "Build a complete e-commerce site"
✅ "Create a product catalog component that displays items in a grid layout with images, titles, and prices"

​
Use Progressive Enhancement

Start Simple, Add Complexity:
  • Begin with core functionality
  • Add features incrementally
  • Test each addition before proceeding
  • Use discussion mode for planning complex features
Iterative Refinement:
  • Implement basic versions first
  • Enhance with additional features
  • Refine based on testing and feedback
  • Maintain clear version control

​
Leverage AI Thinking Features

​
Understanding AI Reasoning

CodinIT provides visual insights into the AI’s thinking process: Thinking Process Display:
  • See step-by-step reasoning for complex tasks
  • Understand how the AI breaks down problems
  • Follow the logical flow of solutions
Thought Artifacts:
  • Expandable reasoning containers
  • Detailed explanation of decision-making
  • Visual representation of problem-solving steps

​
Using Discussion Mode Effectively

Planning Phase:
  • Use discussion mode for architecture decisions
  • Get guidance without code implementation
  • Explore multiple solution approaches
  • Understand trade-offs and implications
Implementation Phase:
  • Switch to regular chat for code generation
  • Reference discussion insights in prompts
  • Build upon planned architectures
  • Iterate based on discussion feedback

​
Optimizing for Different AI Models

​
Understanding Model Capabilities

Different AI providers have different strengths: Claude (Anthropic):
  • Excellent at reasoning and analysis
  • Strong code generation capabilities
  • Good for complex problem-solving
GPT Models (OpenAI):
  • Fast and versatile
  • Good for creative tasks
  • Strong at following detailed instructions
Other Models:
  • Specialized capabilities vary by provider
  • Consider context limits and pricing
  • Test different models for your use case

​
Adapting Your Prompts

Model-Specific Approaches:
  • Adjust complexity based on model capabilities
  • Use different prompting styles for different models
  • Consider model context windows when structuring requests
  • Optimize for speed vs. quality based on your needs

​
Best Practices Summary

​
Communication Strategies

Clear and Concise:
  • State your goal upfront
  • Provide specific requirements
  • Include relevant context
  • Avoid ambiguous language
Structured Requests:
  • Break complex tasks into steps
  • Use numbered lists for multi-part requests
  • Specify file locations when relevant
  • Include examples when helpful
Iterative Approach:
  • Start with core functionality
  • Add features incrementally
  • Test and refine as you go
  • Use discussion mode for planning

​
Model-Aware Prompting

Context Awareness:
  • Consider model context limits
  • Provide necessary background information
  • Reference existing code when relevant
  • Be mindful of token usage
Quality vs. Speed:
  • Use larger models for complex tasks
  • Choose faster models for simple iterations
  • Balance cost and performance needs
  • Optimize prompts for your chosen model
Continuous Learning: Effective prompting improves with practice. Pay attention to what works well and refine your approach over time.
Start Simple: Begin with clear, straightforward prompts and add complexity as you become more comfortable with the system.
For all designs I ask you to make, have them be beautiful, not cookie cutter. Make webpages that are fully featured and worthy for production.

By default, this template supports JSX syntax with Tailwind CSS classes, the shadcn/ui library, React hooks, and Lucide React for icons. Do not install other packages for UI themes, icons, etc unless absolutely necessary or I request them.

Use icons from lucide-react for logos.

Use stock photos from unsplash where appropriate.

​
Tips for the project or system prompts

  • Include instructions to CodinIT.dev to only change relevant code.