Overview

Deep client analysis, product design, and implementation planning. Use when analyzing client needs, designing solutions, creating technical architecture, or building implementation guides for client projects. Combines pattern recognition, solution design, and step-by-step build plans. Apply automatically when the request matches; the user does not need to mention this skill.

This skill should apply automatically when the request matches; the user does not need to mention this skill.

Usage

Use this skill when the request matches its description. The skill is discovered automatically; the user does not need to mention the skill explicitly.

Get to Know a Client

This skill provides a comprehensive process for understanding clients deeply, designing tailored solutions, and creating detailed implementation plans.

When to Use This Skill

Use this skill when:

• Analyzing client notes or meeting transcripts
• Designing products or solutions for a client
• Creating technical implementation guides
• Planning multi-phase client projects
• Determining pricing strategies for client work

The Process

Phase 1: Deep Client Understanding

Read and analyze all available client information (notes, transcripts, documents, previous work).

Identify patterns across six dimensions:

1. Behavioral - How they operate day-to-day
2. Cognitive - How they think and process information
3. Emotional - What drives and blocks them
4. Business - How their business operates
5. Technical - Their relationship with technology
6. Relationship - How they interact with others

For detailed pattern analysis guidance, read /home/ubuntu/skills/get-to-know-a-client/references/client_analysis_framework.md.

Extract gems - Small pockets of wisdom that reveal deeper truths about the client.

Identify three problem layers:

• Surface problems (what they say they need)
• Root problems (what's actually causing issues)
• Opportunity problems (what they don't know they need)

Phase 2: Solution Design

Design a solution that matches the client's operating style and solves root problems, not just surface symptoms.

Create a layered solution:

Layer 1: Immediate Relief

• Quick wins (days to weeks)
• Proof of concept
• Low risk, visible results
• Often FREE or low-cost to clear relationship debt and prove value

Layer 2: Sustainable System

• Automated workflows
• Scalable infrastructure
• Reduced manual work
• Core value delivery

Layer 3: Strategic Transformation

• New revenue streams
• Market expansion
• Long-term vision realized
• Competitive advantages

Leverage existing assets:

• Content they already have
• Tools they already use
• Knowledge they already possess
• Audience they already built

For product design patterns and architecture guidance, read /home/ubuntu/skills/get-to-know-a-client/references/product_design_framework.md.

Phase 3: Technical Architecture

Design the complete system architecture:

Map the data flow:

Input Sources
    ↓
Processing Pipeline
    ↓
Storage Layer
    ↓
User Interface
    ↓
Output/Distribution

Choose appropriate technology:

• Match client's technical literacy
• Consider maintenance capacity
• Evaluate budget constraints
• Plan for scalability
• Leverage existing infrastructure when possible

Common patterns:

• Content Transformation (podcast → 50+ pieces)
• Knowledge Base as a Service (RAG systems)
• Workflow Automation (n8n, Zapier, Edge Functions)
• Community Platforms (Skool, Circle, custom)
• AI-Powered Dashboards (React + Supabase + AI)

Phase 4: Implementation Planning

Create a detailed, phase-by-phase implementation guide.

Structure:

1. Overview - What we're building and why
2. Architecture Diagram - Visual system representation
3. Technology Stack - Complete list of tools
4. Phase-by-Phase Plan - Detailed breakdown
5. Step-by-Step Instructions - Exact commands and code
6. Cost Breakdown - Development and operational costs
7. Success Metrics - How to measure results

Phase structure:

Phase 1: Quick Demo (Days)

• Manual process to prove value
• Sample outputs
• Client sees it working

Phase 2: Core System (Weeks)

• Automated pipeline
• Backend implementation
• API integrations

Phase 3: User Interface (Weeks)

• Dashboard or frontend
• User experience
• Feature implementation

Phase 4: Polish & Launch (Week)

• Testing and bug fixes
• Optimization
• Client training
• Production deployment

For each phase, provide:

• Clear goal
• Exact steps to execute
• Code snippets and commands
• Configuration files
• Testing procedures
• Deliverables

Phase 5: Pricing Strategy

Determine appropriate pricing based on project type and client context.

Project-Based Pricing

Use when:

• Clear scope and deliverables
• Fixed timeline
• One-time implementation
• Client prefers predictability

Calculate:

• Estimate hours × hourly rate
• Add 20-30% buffer
• Consider value delivered, not just time
• Research market rates

Value-Based Pricing (10/10 Principle)

Use when:

• Measurable ROI (revenue saved/made)
• Long-term partnership potential
• Client is cash-flow constrained
• Want aligned incentives

Structure:

• 10% of revenue saved + 10% of revenue made
• 12-month commitment
• Monthly or quarterly reconciliation
• Clear metrics and tracking

Hybrid Pricing

Use when:

• Multi-phase projects
• Uncertain scope
• Want to prove value first

Structure:

• Phase 1: FREE or low-cost (proof of concept)
• Phase 2-3: Project-based or value-based
• Option to switch models after Phase 1

Deliverables

Create and deliver these documents:

1. Client Analysis - Deep pattern analysis and gems
2. Solution Design - Layered approach with architecture
3. Implementation Guide - Step-by-step technical instructions
4. Complete Build Plan - Executive summary with timeline and pricing
5. Visual Diagrams - Workflow and architecture diagrams (use Mermaid)

Key Principles

Understand deeply before designing - Don't jump to solutions. Spend time understanding the client's patterns, motivations, and constraints.

Solve root problems, not symptoms - Content creation isn't the problem if distribution is broken. More features won't help if adoption is low.

Match the client's operating style - Don't give perfectionists "good enough" solutions. Don't give pragmatists over-engineered systems.

Leverage existing assets - Use what they already have. Don't rebuild what can be adapted. Compound their existing strengths.

Start simple, scale smart - Build MVP first. Validate with real usage. Add complexity only when needed.

Design for maintenance - Document everything. Use standard technologies. Plan for handoff or ongoing support.

Build toward their vision - Every solution should be a step toward their long-term goal. Quick wins should fund bigger vision.

Red Flags

Watch for warning signs:

Client Red Flags:

• Unwilling to invest in their own business
• Constantly changing requirements
• Poor communication or unresponsive
• Unrealistic expectations
• Doesn't value your expertise

Project Red Flags:

• Unclear success metrics
• No decision-maker access
• Scope creep without budget adjustment
• Technology constraints you can't work with
• Timeline impossible to meet

Relationship Red Flags:

• One-sided benefit
• Lack of trust or transparency
• Misaligned values
• Exploitation dynamics
• No long-term potential

If multiple red flags appear, reconsider the engagement or adjust terms.

Success Metrics

Client Success:

• Revenue increased
• Time saved
• Stress reduced
• Quality improved
• Market expanded

Project Success:

• High adoption rate
• Frequent usage
• ROI achieved
• Client satisfied
• Referrals generated

Relationship Success:

• Quality communication
• Mutual respect
• Aligned incentives
• Long-term commitment
• Collaborative problem-solving

Example Workflow

1. Receive client notes (meeting transcript, project brief)
2. Read client analysis framework to guide pattern recognition
3. Analyze patterns across six dimensions
4. Extract gems and insights
5. Identify problem layers (surface, root, opportunity)
6. Read product design framework to guide solution design
7. Design layered solution (immediate, sustainable, strategic)
8. Create technical architecture (data flow, tech stack)
9. Build implementation guide (phase-by-phase with code)
10. Determine pricing (project-based, value-based, or hybrid)
11. Create deliverables (analysis, design, guide, plan, diagrams)
12. Present to client or deliver to Brandon for execution

Integration with Other Skills

This skill works well with:

• brainstorm-logos - Use AFTER brainstorm-logos when moving from personal ideas to client execution
• systematic-feature-builder - Use BEFORE feature-builder when implementing the designed solution
• systematic-debugging - Use DURING implementation when issues arise
• brainstorming - Use BEFORE this skill for initial exploration of client needs

Notes

• This skill assumes you have access to client information (notes, transcripts, documents)
• Always prioritize understanding over speed - deep analysis leads to better solutions
• Document everything - clients appreciate thoroughness and clarity
• Challenge assumptions - what the client says they need may not be what they actually need
• Think long-term - every project should build toward the client's bigger vision