A comprehensive system for creating effective AI collaboration setups that combines structured frameworks with adaptive, friction-driven development.
Works with any AI provider that supports custom instructions and persistent context. Designed primarily for Claude Projects but fully applicable to ChatGPT, Gemini, and other LLM platforms.
Transforms any AI assistant from a generic tool into a personalised collaborator that:
- Understands your context without repeated explanation
- Adapts to your skill level and constraints
- Learns your preferences through actual use
- Evolves with your needs over time
Two philosophies combined:
From established research (prompt engineering):
- Structured templates and frameworks
- Operating modes for different interaction types
- Systematic friction tracking
- Memory as learned patterns
From real-world AI collaboration experience:
- Start minimal, expand deliberately
- Context over commands
- Trust adaptation when possible
- Let real use guide development
Result: Start light but structured, evolve through friction, end with something genuinely yours.
A complete system for designing effective AI collaboration setups through friction-driven development.
📁 Templates - Starter (essential 5 sections) + Advanced (optional expansions)
📂 Examples - Health/fitness and career/coding filled examples showing evolution
📚 Guides - Implementation, memory development, personal preferences (account-level), template usage, quick-start checklist
📖 Reference - Glossary of terms and concepts, comprehensive project index
→ See PROJECT-INDEX.md for detailed descriptions of all files
Traditional structured approach says: "Define everything upfront with comprehensive templates"
Pure adaptive approach says: "Just give context and let the AI figure it out"
This hybrid approach says: "Start with essential structure, trust adaptation, expand deliberately through real friction"
You can't anticipate what you don't know yet.
- First-time users don't know their preferences
- Context reveals itself through use
- Friction shows exactly what to improve
But some structure helps:
- Starting point prevents blank-page paralysis
- Framework offers expansion options when needed
- Templates show what's possible
The balance:
- Essential structure upfront (who, what, constraints)
- Trust the AI's adaptation from context
- Add specificity only when friction reveals need
Fill in five core sections:
- Context: Who you are, what you're doing
- Constraints: Time, resources, limitations (be honest)
- Goals: 3-5 specific objectives
- Preferences: How you want to work (2-4 certainties)
- Red Flags: What definitely won't work
Add to your AI system's custom instructions → Use for one week
For Claude: Add to Project Custom Instructions
For ChatGPT: Add to Custom Instructions in Settings
For GitHub Copilot: Create .github/copilot-instructions.md in your repository
For Gemini: Create a Gem with these instructions
For other AIs: Use your platform's equivalent persistent instruction field
The Rule of Three:
- 1st correction: Note it
- 2nd correction: Pattern maybe?
- 3rd correction: Confirmed pattern → capture it
Use friction-detection prompts:
"I've noticed I keep correcting [X]. This is the third time.
Help me create a memory instruction for this."
Add optional sections only when friction reveals you need them:
- Operating Modes → Interactions feel too uniform
- Decision Framework → Priorities don't align
- Domain Principles → Core beliefs keep getting violated
- Success Metrics → Want systematic progress tracking
- Response Structure → Keep reformatting outputs
Don't add everything. Add what friction reveals you need.
- Review what worked
- Update changed context
- Refine vague instructions
- Remove obsolete patterns
Your complete AI collaboration system has three levels:
Personal Preferences (Account-wide):
- Universal standards for ALL AI conversations
- Language, communication style, work quality expectations
- Set once in account settings, applies everywhere
- Example: "Use British English" or "Always verify syntax before suggesting tests"
- → See Personal Preferences Guide
Platform-specific:
- Claude: Personal Preferences in Settings → Profile
- ChatGPT: Custom Instructions in Settings
- GitHub Copilot: Personal Instructions (github.com/copilot → profile menu)
- Gemini: Account-level settings
- Other AIs: Account-level settings where available
Project Context (Project-specific):
- Context for THIS domain/project
- Your goals, constraints, background
- What you know before starting
- Example: "I'm learning Python for data science with limited time"
- → See Project Context Guide
Platform-specific:
- Claude: Project Custom Instructions
- ChatGPT: GPTs or conversation-specific instructions
- GitHub Copilot: Repository Instructions (
.github/copilot-instructions.md) - Gemini: Gems (custom AI instances)
- Other AIs: Per-session or project-specific prompts
Project Memory (Learned patterns):
- What you discover through friction
- Specific corrections after Rule of Three
- Evolves continuously through use
- Example: "When suggesting exercises, ask about equipment first"
- → See Memory Guide
Platform-specific:
- Claude: Project Memory feature
- ChatGPT: Memory feature or persistent instructions
- GitHub Copilot: Append to repository instructions (manual evolution)
- Gemini: Append to Gem instructions (manual evolution)
- Other AIs: Append to system prompt or use platform's memory equivalent
Together: Universal baseline + Project context + Learned patterns = Personalised system
Understanding the difference between project-level instructions:
Project Context (Custom Instructions):
- What you know before starting THIS project
- Your context, goals, constraints for this domain
- General project preferences
- Doesn't change often
Project Memory:
- What you learn through using THIS project
- Specific corrections from friction
- Discovered project-specific preferences
- Evolves continuously
Together with Personal Preferences: Universal baseline (preferences) + Starting hypothesis (system prompt) + Findings (memory) = Continuously improving system
Don't capture every correction as a pattern.
Pattern recognition:
- Occurs once → Could be fluke, just correct it
- Occurs twice → Might be pattern, note it
- Occurs three times → Confirmed pattern, capture it
Why this works:
- Filters signal from noise
- Prevents over-specification
- Ensures real patterns
- Keeps system lean
Friction = Gap between what the AI gives and what you need
Good friction (capture it):
- Same correction three+ times
- Consistent preference not being honoured
- Regular misunderstanding of context
Normal friction (don't capture):
- One-off mistakes
- You changed your mind
- Edge case unlikely to recur
The insight: Friction tells you exactly what your system is missing.
❌ Repeat context every conversation
✅ AI remembers your situation
❌ Generic advice for everyone
✅ Tailored to your constraints
❌ Trial and error every time
✅ Learns from patterns
❌ Guess all preferences upfront
✅ Discover through real use
❌ Rigid templates limiting adaptation
✅ Structure with flexibility
❌ Complex setup, rarely maintained
✅ Simple start, deliberate evolution
✅ Start with enough structure to work
✅ Trust the AI to adapt from context
✅ Expand only when friction reveals needs
✅ Evolve continuously through use
✅ Maintain through lightweight reviews
- Personalised training programmes
- Nutrition guidance fitting your life
- Progress tracking and adaptation
- Form coaching and injury prevention
Key benefit: Knows your equipment, schedule, skill level, past failures - no repeated explanations.
- Skill roadmap matched to your level
- Project-based learning plans
- Code review and debugging help
- Strategic career guidance
Key benefit: Understands where you are, where you're going, what you actually have time for.
- Writing in your voice
- Audience-specific adaptations
- Content strategy aligned with goals
- Performance-driven refinements
Key benefit: Writes like you, for your audience, with your strategy.
- Personalised curriculum
- Explanations at your level
- Progressive difficulty
- Pattern recognition in your learning
Key benefit: Teaches at your pace, builds on what you know, adapts to how you learn.
The pattern: Any domain where context matters and you'll interact repeatedly.
- Open
starter-template.md - Fill five essential sections (20 min)
- Add to your AI system's custom instructions (5 min)
- Test with 2-3 questions (5 min)
- Use for one week, note friction
Best for: First-time users, new domains, exploratory projects
- Read implementation guide (30 min)
- Review relevant example (15 min)
- Fill starter template thoughtfully (45 min)
- Add and test (15 min)
- Use Week 1, track friction daily (15 min)
- Week 2-3: Add memory instructions (30 min)
- Month 1 review and refine (30 min)
Best for: Important projects, want to do it right, willing to invest time
- Minimal setup with starter template (15 min)
- Jump into using it
- Fix friction as you notice it
- Check guides when stuck
- Review examples when expanding
- Let the system evolve organically
Best for: Learn-by-doing types, experimental approach, comfortable with iteration
- ✓ Less need to explain basic context
- ✓ Responses at appropriate skill/detail level
- ✓ Fewer obviously wrong suggestions
- ✓ Tone feels approximately right
- ✓ 3-5 memory instructions working
- ✓ Significantly less friction on common tasks
- ✓ Understanding of what works for you
- ✓ Confidence in core setup
- ✓ Well-calibrated system needing little adjustment
- ✓ Memory instructions covering main patterns
- ✓ Optional sections added only where genuinely useful
- ✓ Productive collaboration with your AI
If not seeing these: Check troubleshooting section in implementation guide.
- Start minimal and expand deliberately
- Be honest about constraints and skill level
- Use the rule of three for patterns
- Let friction guide improvements
- Review and maintain monthly
- Trust the AI's adaptation from context
- Document reality, not aspirations
- Don't try to anticipate everything upfront
- Don't add sections "just in case"
- Don't copy examples without customising
- Don't ignore recurring friction
- Don't add memory after single occurrence
- Don't let system stagnate without review
- Don't expect perfection immediately
"How is this different from just using Custom Instructions normally?"
Most people either leave custom instructions empty or write a few vague sentences. This system provides:
- Structure for what to include
- Guidance on appropriate detail level
- Framework for evolution through friction
- Distinction between prompt and memory
"Do I need to fill in everything in the advanced template?"
No! The advanced template shows what's possible to add. Most projects only need 20-30% of those sections. Let friction tell you what you actually need.
"What if my project doesn't fit these categories?"
Templates are starting points, not restrictions. Adapt freely. The core concept (context + constraints + goals + friction-driven evolution) works for any domain.
"How long until I see results?"
- Immediate: Better than no setup
- Week 1: Noticeably more relevant
- Month 1: Significantly personalised
- Month 3: Feels genuinely collaborative
"Can I use this with ChatGPT, Gemini, Copilot, or other AIs?"
Absolutely! The framework is platform-agnostic. The core concepts (context, constraints, goals, friction-driven evolution) work with any AI system that supports custom instructions.
Platform differences:
- Claude Projects: Native support for separate Custom Instructions and Memory makes implementation straightforward
- ChatGPT: Use Custom Instructions (account-level) and GPTs or conversation context (project-level), plus Memory feature
- GitHub Copilot: Personal Instructions (account-level) and Repository Instructions (project-level via
.github/copilot-instructions.md) - Gemini: Account settings and Gems (custom AI instances)
- Other AIs: Adapt to your platform's instruction/memory capabilities
The friction-driven methodology works regardless of platform - just adjust how you store and structure your instructions.
"What if I have multiple related projects?"
See "Multi-Project Coordination" in implementation guide. Options include shared core documents or cross-references between projects.
See PROJECT-INDEX.md for the complete file tree and detailed descriptions of each file.
Quick overview:
- Templates (starter + advanced)
- Examples (health/fitness + career/coding)
- Guides (implementation, memory, usage, quick-start)
- Reference (glossary + project index)
New to this? → Start with this README → Starter Template → Project Context Guide
Ready to build? → Starter Template → Relevant Example → Project Context Guide (Quick Start section)
Have existing project? → Project Context Guide (Applying to Existing Projects section)
Want to understand memory? → Memory Guide
Need troubleshooting? → Project Context Guide (Troubleshooting section)
Want to see examples? → Examples folder
This system combines insights from:
- Prompt engineering research and best practices
- Real-world AI collaboration experience across platforms
- Friction-driven development methodology
- Implementation patterns from Claude, ChatGPT, and other AI systems
Found a better approach? Discovered new patterns?
- Share examples of what worked
- Document friction patterns worth capturing
- Suggest improvements to templates or guides
The goal isn't perfection on day one. It's a system that:
- Works well enough immediately
- Improves through real use
- Captures what matters to you specifically
- Evolves as your needs change
Start with the essentials. Let friction guide you. Build through iteration, not imagination.
The best collaboration system is one that grew with you, not one that tried to predict everything upfront.
Ready to begin?
- Open
/templates/starter-template.md - Fill in five sections (20 min)
- Add to your AI system's custom instructions
- Start working
- Notice friction
- Capture patterns
- Evolve continuously
Good luck! 🚀