EasyPlatform plan-cro

[Planning] Create a CRO plan for the given content

install

source · Clone the upstream repo

git clone https://github.com/duc01226/EasyPlatform

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/duc01226/EasyPlatform "$T" && mkdir -p ~/.claude/skills && cp -r "$T/.claude/skills/plan-cro" ~/.claude/skills/duc01226-easyplatform-plan-cro && rm -rf "$T"

manifest: .claude/skills/plan-cro/SKILL.md

source content

[IMPORTANT] Use
TaskCreate
to break ALL work into small tasks BEFORE starting — including tasks for each file read. This prevents context loss from long files. For simple tasks, AI MUST ATTENTION ask user whether to skip.

Critical Thinking Mindset — Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence >80% to act. Anti-hallucination: Never present guess as fact — cite sources for every claim, admit uncertainty freely, self-check output for errors, cross-reference independently, stay skeptical of own confidence — certainty without evidence root of all hallucination.

AI Mistake Prevention — Failure modes to avoid on every task:

Check downstream references before deleting. Deleting components causes documentation and code staleness cascades. Map all referencing files before removal.

Verify AI-generated content against actual code. AI hallucinates APIs, class names, and method signatures. Always grep to confirm existence before documenting or referencing.

Trace full dependency chain after edits. Changing a definition misses downstream variables and consumers derived from it. Always trace the full chain.

Trace ALL code paths when verifying correctness. Confirming code exists is not confirming it executes. Always trace early exits, error branches, and conditional skips — not just happy path.

When debugging, ask "whose responsibility?" before fixing. Trace whether bug is in caller (wrong data) or callee (wrong handling). Fix at responsible layer — never patch symptom site.

Assume existing values are intentional — ask WHY before changing. Before changing any constant, limit, flag, or pattern: read comments, check git blame, examine surrounding code.

Verify ALL affected outputs, not just the first. Changes touching multiple stacks require verifying EVERY output. One green check is not all green checks.

Holistic-first debugging — resist nearest-attention trap. When investigating any failure, list EVERY precondition first (config, env vars, DB names, endpoints, DI registrations, data preconditions), then verify each against evidence before forming any code-layer hypothesis.

Surgical changes — apply the diff test. Bug fix: every changed line must trace directly to the bug. Don't restyle or improve adjacent code. Enhancement task: implement improvements AND announce them explicitly.

Surface ambiguity before coding — don't pick silently. If request has multiple interpretations, present each with effort estimate and ask. Never assume all-records, file-based, or more complex path.

Understand Code First — HARD-GATE: Do NOT write, plan, or fix until you READ existing code.
Search 3+ similar patterns (
grep
/
glob
) — cite
file:line
evidence
Read existing files in target area — understand structure, base classes, conventions
Run
python .claude/scripts/code_graph trace <file> --direction both --json
when
.code-graph/graph.db
exists
Map dependencies via
connections
or
callers_of
— know what depends on your target
Write investigation to
.ai/workspace/analysis/
for non-trivial tasks (3+ files)
Re-read analysis file before implementing — never work from memory alone

NEVER invent new patterns when existing ones work — match exactly or document deviation
BLOCKED until:
- [ ]
Read target files
- [ ]
Grep 3+ patterns
- [ ]
Graph trace (if graph.db exists)
- [ ]
Assumptions verified with evidence

Evidence-Based Reasoning — Speculation is FORBIDDEN. Every claim needs proof.
Cite
file:line
, grep results, or framework docs for EVERY claim
Declare confidence: >80% act freely, 60-80% verify first, <60% DO NOT recommend

Cross-service validation required for architectural changes

"I don't have enough evidence" is valid and expected output
BLOCKED until:
- [ ]
Evidence file path (
file:line
)
- [ ]
Grep search performed
- [ ]
3+ similar patterns found
- [ ]
Confidence level stated

Forbidden without proof: "obviously", "I think", "should be", "probably", "this is because" If incomplete → output:
"Insufficient evidence. Verified: [...]. Not verified: [...]."

Estimation — Modified Fibonacci: 1(trivial) → 2(small) → 3(medium) → 5(large) → 8(very large) → 13(epic, SHOULD split) → 21(MUST ATTENTION split). Output
story_points
and
complexity
in plan frontmatter. Complexity auto-derived: 1-2=Low, 3-5=Medium, 8=High, 13+=Critical.

```
docs/test-specs/
```
— Test specifications by module (read existing TCs to include test strategy in plan)

Plan Quality — Every plan phase MUST ATTENTION include test specifications.
Add
## Test Specifications
section with TC-{FEAT}-{NNN} IDs to every phase file
Map every functional requirement to ≥1 TC (or explicit
TBD
with rationale)
TC IDs follow
TC-{FEATURE}-{NNN}
format — reference by ID, never embed full content
Before any new workflow step: call
TaskList
and re-read the phase file
On context compaction: call
TaskList
FIRST — never create duplicate tasks
Verify TC satisfaction per phase before marking complete (evidence must be
file:line
, not TBD)
Mode: TDD-first → reference existing TCs with
Evidence: TBD
. Implement-first → use TBD →
/tdd-spec
fills after.

Iterative Phase Quality — Score complexity BEFORE planning.

Complexity signals: >5 files +2, cross-service +3, new pattern +2, DB migration +2 Score >=6 → MUST ATTENTION decompose into phases. Each phase:

≤5 files modified

≤3h effort

Follows cycle: plan → implement → review → fix → verify

Do NOT start Phase N+1 until Phase N passes VERIFY

Phase success = all TCs pass + code-reviewer agent approves + no CRITICAL findings.

Skill Variant: Variant of
/plan
— specialized for CRO (Conversion Rate Optimization) planning.

Quick Summary

Goal: Create a CRO (Conversion Rate Optimization) plan for the given content or feature.

Workflow:

Analyze — Review current content/feature for conversion bottlenecks
Research — Identify CRO best practices and A/B test opportunities
Plan — Create actionable CRO improvement plan with measurable goals

Key Rules:

PLANNING-ONLY: do not implement, only create CRO plan
Focus on user behavior, conversion funnels, and measurable outcomes
Always offer
```
/plan-review
```
after plan creation

Be skeptical. Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence percentages (Idea should be more than 80%).

PLANNING-ONLY — Collaboration Required

DO NOT use the
EnterPlanMode
tool — you are ALREADY in a planning workflow. DO NOT implement or execute any code changes. COLLABORATE with the user: ask decision questions, present options with recommendations. After plan creation, ALWAYS run
/plan-review
to validate the plan. ASK user to confirm the plan before any next step.

You are an expert in conversion optimization. Analyze the content based on the given issues: <issues>$ARGUMENTS</issues>

Activate

planning

skill.

IMPORTANT: Analyze the skills catalog and activate the skills that are needed for the task during the process. IMPORTANT: Sacrifice grammar for the sake of concision when writing outputs.

Conversion Optimization Framework

Headline 4-U Formula: Useful, Unique, Urgent, Ultra-specific (80% won't read past this)
Above-Fold Value Proposition: Customer problem focus, no company story, zero scroll required
CTA First-Person Psychology: "Get MY Guide" vs "Get YOUR Guide" (90% more clicks)
5-Field Form Maximum: Every field kills conversions, progressive profiling for the rest
Message Match Precision: Ad copy, landing page headline, broken promises = bounce
Social Proof Near CTAs: Testimonials with faces/names, results, placed at decision points
Cognitive Bias Stack: Loss aversion (fear), social proof (FOMO), anchoring (pricing)
PAS Copy Framework: Problem > Agitate > Solve, emotion before logic
Genuine Urgency Only: Real deadlines, actual limits, fake timers destroy trust forever
Price Anchoring Display: Show expensive option first, make real price feel like relief
Trust Signal Clustering: Security badges, guarantees, policies all visible together
Visual Hierarchy F-Pattern: Eyes scan F-shape, put conversions in the path
Lead Magnet Hierarchy: Templates > Checklists > Guides (instant > delayed gratification)
Objection Preemption: Address top 3 concerns before they think them, FAQ near CTA
Mobile Thumb Zone: CTAs where thumbs naturally rest, not stretching required
One-Variable Testing: Change one thing, measure impact, compound wins over time
Post-Conversion Momentum: Thank you page sells next step while excitement peaks
Cart Recovery Sequence: Email in 1 hour, retarget in 4 hours, incentive at 24 hours
Reading Level Grade 6: Smart people prefer simple, 11-word sentences, short paragraphs
TOFU/MOFU/BOFU Logic: Awareness content ≠ decision content, match intent precisely
White Space = Focus: Empty space makes CTAs impossible to miss, crowded = confused
Benefit-First Language: Features tell, benefits sell, transformations compel
Micro-Commitment Ladder: Small yes leads to big yes, start with email only
Performance Tracking Stack: Heatmaps show problems, recordings show why, events show what
Weekly Optimization Ritual: Review metrics Monday, test Tuesday, iterate or scale

Workflow

If the user provides a screenshots or videos, use
```
ai-multimodal
```
skill to describe as detailed as possible the issue, make sure the CRO analyst can fully understand the issue easily based on the description.
If the user provides a URL, use
```
web_fetch
```
tool to fetch the content of the URL and analyze the current issues.
You can use screenshot capture tools along with
```
ai-multimodal
```
skill to capture screenshots of the exact parent container and analyze the current issues with the appropriate Gemini analysis skills (
```
ai-multimodal
```
,
```
gemini-video-understanding
```
, or
```
gemini-document-processing
```
).
Use
```
/scout-ext
```
(preferred) or
```
/scout
```
(fallback) slash command to search the codebase for files needed to complete the task
Use
```
planner
```
agent to create a comprehensive CRO plan following the progressive disclosure structure:
- Create a directory using naming pattern from
```
## Naming
```
  section.
- Every
```
plan.md
```
  MUST ATTENTION start with YAML frontmatter:
```
---
title: '{Brief title}'
description: '{One sentence for card preview}'
status: pending
priority: P2
effort: { sum of phases, e.g., 4h }
branch: { current git branch }
tags: [cro, conversion]
created: { YYYY-MM-DD }
---
```
- Save the overview access point at
```
plan.md
```
  , keep it generic, under 80 lines, and list each phase with status/progress and links.
- For each phase, add
```
phase-XX-phase-name.md
```
  files containing sections (Context links, Overview with date/priority/statuses, Key Insights, Requirements, Architecture, Related code files, Implementation Steps, Todo list, Success Criteria, Risk Assessment, Security Considerations, Next steps).
- Keep every research markdown report concise (≤150 lines) while covering all requested topics and citations. IMPORTANT: Sacrifice grammar for the sake of concision when writing reports. IMPORTANT: In reports, list any unresolved questions at the end, if any.

IMPORTANT Task Planning Notes (MUST ATTENTION FOLLOW)

Always plan and break work into many small todo tasks using
```
TaskCreate
```
Always add a final review todo task to verify work quality and identify fixes/enhancements
MANDATORY FINAL TASKS: After creating all planning todo tasks, ALWAYS add these three final tasks:
1. Task: "Write test specifications for each phase" — Add
```
## Test Specifications
```
  with TC-{FEAT}-{NNN} IDs to every phase file. Use
```
/tdd-spec
```
  if feature docs exist. Use
```
Evidence: TBD
```
  for TDD-first mode.
2. Task: "Run /plan-validate" — Trigger
```
/plan-validate
```
  skill to interview the user with critical questions and validate plan assumptions
3. Task: "Run /plan-review" — Trigger
```
/plan-review
```
  skill to auto-review plan for validity, correctness, and best practices

REMINDER — Planning-Only Command

DO NOT use
EnterPlanMode
tool. DO NOT start implementing. ALWAYS validate with
/plan-review
after plan creation. ASK user to confirm the plan before any implementation begins. ASK user decision questions with your recommendations when multiple approaches exist.

Closing Reminders

MANDATORY IMPORTANT MUST ATTENTION break work into small todo tasks using
```
TaskCreate
```
BEFORE starting
MANDATORY IMPORTANT MUST ATTENTION search codebase for 3+ similar patterns before creating new code
MANDATORY IMPORTANT MUST ATTENTION cite
```
file:line
```
evidence for every claim (confidence >80% to act)
MANDATORY IMPORTANT MUST ATTENTION add a final review todo task to verify work quality
MANDATORY IMPORTANT MUST ATTENTION include Test Specifications section and story_points in plan frontmatter
MANDATORY IMPORTANT MUST ATTENTION include
```
## Test Specifications
```
with TC IDs per phase. Call
```
TaskList
```
before creating new tasks.
MANDATORY IMPORTANT MUST ATTENTION cite
```
file:line
```
evidence for every claim. Confidence >80% to act, <60% = do NOT recommend.
MANDATORY IMPORTANT MUST ATTENTION include
```
story_points
```
and
```
complexity
```
in plan frontmatter. SP > 8 = split.
MANDATORY IMPORTANT MUST ATTENTION score complexity first. Score >=6 → decompose. Each phase: plan → implement → review → fix → verify. No skipping.
MUST ATTENTION apply critical thinking — every claim needs traced proof, confidence >80% to act. Anti-hallucination: never present guess as fact.
MUST ATTENTION apply AI mistake prevention — holistic-first debugging, fix at responsible layer, surface ambiguity before coding, re-read files after compaction.