🔍 Claude Code User Documentation Review - 2026-02-07

[github-actions]

Executive Summary

As a Claude Code user reviewing gh-aw documentation, I found that the project has excellent engine-agnostic architecture and full Claude support, but documentation presentation could be clearer for non-Copilot users. The good news: Claude users CAN successfully adopt gh-aw with minimal friction. The improvement opportunity: some documentation uses Copilot-first language that initially obscures the equal support for Claude.

Key Finding: Claude Code users can successfully use gh-aw. The architecture is genuinely engine-agnostic, authentication is well-documented, and 29 Claude example workflows exist in the repository. However, Quick Start and README emphasize Copilot in ways that could initially mislead Claude users into thinking Copilot is required or preferred.

---

Persona Context

I reviewed this documentation as a developer who:

• ✅ Uses GitHub for version control
• ✅ Uses Claude Code as primary AI assistant
• ❌ Does NOT use GitHub Copilot
• ❌ Does NOT use Copilot CLI
• ❌ Does NOT have Copilot subscription

---

Question 1: Onboarding Experience

Can a Claude Code user understand and get started with gh-aw?

Answer: Yes, but with initial confusion.

The Quick Start guide (docs/src/content/docs/setup/quick-start.mdx) actually handles this well through the interactive add-wizard command, which prompts users to select between Claude, Copilot, or Codex. However, the prerequisite section creates initial uncertainty by listing Copilot first without clearly indicating these are alternatives:

Current Text (Quick Start Prerequisites):

- ✅ **AI Account** - A [GitHub Copilot](https://github.com/features/copilot) subscription, 
     or a [Anthropic Claude](https://www.anthropic.com/) or [OpenAI Codex]((openai.com/redacted) API key

Issue: The word "or" appears mid-sentence, making it easy to miss that these are alternatives. A Claude user might read this and think "I need Copilot AND Claude."

Specific Issues Found:

1. Quick Start Prerequisites (Line 17) - Lists "GitHub Copilot subscription, or a Anthropic Claude..." without clear visual separation showing these are alternatives
2. README.md (Line 23) - Example workflow shown uses Copilot CLI by default in explanation text
3. Quick Start Step 2 - The add-wizard command correctly prompts for engine selection, but this isn't mentioned in the prerequisite section

Recommended Fixes:

1. Restructure prerequisites to use a table or bulleted list showing ONE of the following:

   - ✅ **AI Engine** (choose ONE):
     - **GitHub Copilot** - Subscription required, uses `COPILOT_GITHUB_TOKEN`
     - **Anthropic Claude** - API key required, uses `ANTHROPIC_API_KEY`
     - **OpenAI Codex** - API key required, uses `OPENAI_API_KEY`

2. Add a callout box early in Quick Start:

   > [!NOTE]
   > Engine Choice
   > You can use gh-aw with Claude, Copilot, or Codex. The `add-wizard` command 
   > will guide you through selecting and configuring your preferred engine.

3. Add forward reference in Prerequisites: "See AI Engines for detailed comparison"

---

Question 2: Inaccessible Features for Non-Copilot Users

What features or steps don't work without Copilot?

Answer: No features require Copilot. Everything is genuinely engine-agnostic.

This is excellent news - I found zero actual dependencies on Copilot. The architecture truly supports multiple engines.

Features That Require Copilot:

• None! All core functionality works with Claude, Copilot, or Codex

Features That Work Without Copilot:

• ✅ All workflow triggers (schedule, issues, PRs, manual)
• ✅ All tools (GitHub, bash, edit, web-fetch, web-search, playwright)
• ✅ All safe-outputs (create-issue, create-pull-request, etc.)
• ✅ MCP server integration (fully engine-agnostic)
• ✅ CLI commands (compile, run, status, logs, audit, etc.)
• ✅ Network permissions and sandboxing
• ✅ Workflow compilation and execution
• ✅ Interactive add-wizard for workflow installation

Engine Distribution Analysis:

• Total workflows in repository: 147
• Claude workflows: 29 (20%)
• Copilot workflows: 69 (47%)
• Codex workflows: 9 (6%)
• Unspecified/other: 40 (27%)

Observations:

• Claude has substantial representation (29 workflows)
• Copilot dominance is likely due to developer team using it, not technical limitations
• The 40 unspecified workflows likely work with any engine

Missing Documentation:

• Missing: Guidance on WHEN to choose Claude vs Copilot vs Codex
• Missing: Claude-specific workflow examples prominently featured in Quick Start
• Missing: Performance/cost comparison between engines
• Missing: Known limitations or differences between engines

---

Question 3: Documentation Gaps and Assumptions

Where does the documentation assume Copilot usage?

Copilot-Centric Language Found In:

1. File: README.md (Line 23-38)

   • Issue: Example workflow explanation mentions "The gh aw cli converts this into a GitHub Actions Workflow (.yml) that runs an AI agent (Copilot, Claude, Codex, ...)"
   • Lists Copilot first in every enumeration
   • Fix: Use "AI agent (Claude, Codex, Copilot, ...)" or alphabetical order

2. File: docs/src/content/docs/reference/engines.md (Title)

   • Issue: First section is "Using Copilot CLI" which appears before Claude section
   • Creates perception that Copilot is default/primary
   • Fix: Either alphabetize sections or add intro stating "Choose your engine" with equal visual weight

3. File: docs/src/content/docs/introduction/how-they-work.mdx (Line 18)

   • Issue: States "Workflows support GitHub Copilot (default), Claude Code, and Codex"
   • Calling Copilot "default" misleads users into thinking it's preferred
   • Fix: "Workflows support Claude, GitHub Copilot, and Codex engines. Choose based on your subscription and requirements."

4. File: docs/src/content/docs/reference/tokens.md

   • Issue: Heavily Copilot-focused due to token complexity
   • Table lists COPILOT_GITHUB_TOKEN first with extensive notes
   • Reality: This is necessary due to Copilot's actual complexity, not bias
   • Fix: Add prominent callout: "Claude users only need ANTHROPIC_API_KEY - see Using Claude Code"

5. File: docs/src/content/docs/reference/faq.md (Line 103)

   • Issue: "Who pays for the use of AI?" lists Copilot first
   • Fix: Alphabetize or group by complexity

Missing Alternative Instructions:

1. Quick Start lacks Claude-first walkthrough

   • Current: Uses generic add-wizard which is good
   • Missing: Explicit "If you're using Claude, here's what happens" section
   • Recommendation: Add collapsible sections for each engine showing the specific flow

2. No Claude API key creation walkthrough

   • Current: Single line "Create an Anthropic API key at https://console.anthropic.com/api-keys"
   • Missing: Screenshots or detailed steps (like what's shown for Copilot PAT creation)
   • Recommendation: Match the detail level of Copilot instructions

3. No comparison guide

   • Missing: "Which engine should I use?" decision tree
   • Missing: Claude strengths (long context, reasoning) vs Copilot strengths (GitHub integration)
   • Missing: Cost comparison guidance
   • Recommendation: Add /gh-aw/guides/choosing-an-engine.md

4. Example workflows not engine-diverse

   • Issue: README and Quick Start show Copilot-oriented workflows
   • Fix: Feature a Claude example prominently in README

---

Severity-Categorized Findings

🚫 Critical Blockers (Score: 0/10 - None Found!)

NO CRITICAL BLOCKERS IDENTIFIED

This is excellent! Claude Code users can successfully onboard and use gh-aw. The architecture is genuinely engine-agnostic.

---

⚠️ Major Obstacles (Score: 2/10 - Minor Friction Only)

Obstacle 1: Quick Start Prerequisites Create False Dependency Perception

Impact: Claude users might initially think Copilot is required

Current State: Prerequisites list "GitHub Copilot subscription, or a Anthropic Claude..." in a way that's easy to misread

Why It's Problematic:

• The word "or" appears mid-sentence without clear visual separation
• Copilot listed first creates perception of primacy
• Could cause Claude users to bounce before realizing they can proceed

Suggested Fix:

- ✅ **AI Engine** - Choose ONE of the following:
  | Engine | Requirement | Secret Name |
  |--------|-------------|-------------|
  | **Claude** | Anthropic API key | `ANTHROPIC_API_KEY` |
  | **Copilot** | GitHub subscription | `COPILOT_GITHUB_TOKEN` |
  | **Codex** | OpenAI API key | `OPENAI_API_KEY` |
  
  See [AI Engines](/gh-aw/reference/engines/) for detailed comparison.

Affected Files:

• docs/src/content/docs/setup/quick-start.mdx (Line 17)
• README.md (Line 15) - similar language in "AI Account" prerequisite

Obstacle 2: "Default" Language Suggests Copilot is Preferred

Impact: Creates perception that Claude is second-class

Current State: Multiple places state "GitHub Copilot (default)" or list Copilot first

Why It's Problematic:

• Suggests Copilot is recommended or better supported
• Claude users wonder if they're missing features
• "Default" implies "what you should use unless you have a reason not to"

Suggested Fix:
Replace "default" language with neutral wording:

• ❌ "Workflows support GitHub Copilot (default), Claude Code, and Codex"
• ✅ "Workflows support multiple AI engines: Claude, Copilot, and Codex. Each has different strengths - choose based on your subscription and needs."

Add engine selection guidance:

## Choosing an Engine

- **Claude**: Long context windows (200K tokens), strong reasoning, competitive pricing
- **Copilot**: Integrated with GitHub subscription, code-aware context, familiar to Copilot users
- **Codex**: Enterprise Azure OpenAI integration, organizational control

Affected Files:

• docs/src/content/docs/introduction/how-they-work.mdx (Line 18)
• docs/src/content/docs/reference/engines.md (Section ordering)
• README.md (Multiple locations listing engines)

---

💡 Minor Confusion Points (Score: 5/10 - Paper Cuts)

1. Engines.md section ordering - "Using Copilot CLI" appears before "Using Claude Code", creating perception of hierarchy - File: docs/src/content/docs/reference/engines.md

2. Missing Claude success stories - No prominent "this workflow uses Claude" callouts in examples - Recommendation: Add badges or indicators showing engine used

3. Token documentation overwhelm - The tokens.md page is very Copilot-heavy due to legitimate complexity, but could scare Claude users - Fix: Add prominent "Claude users: you only need ANTHROPIC_API_KEY" callout at top

4. No visual indicators of engine compatibility - Tools page doesn't clearly state "all tools work with all engines" - Fix: Add callout or table showing tool/engine compatibility matrix (even if it's "all ✅")

5. Example workflow in README uses default engine - The example shown doesn't specify engine, implying Copilot default - Fix: Show example with engine: claude or explicitly state engine can be chosen

6. FAQ ordering - "Who pays for AI" and other sections list Copilot first - Fix: Alphabetize or use consistent neutral ordering

7. No "I'm a Claude user" quickstart path - Documentation is generic, no Claude-specific onboarding flow - Fix: Add Claude-specific quickstart or collapsible "For Claude users" sections

---

Engine Comparison Analysis

Available Engines

Based on my review, gh-aw supports these engines with equal architectural support:

1. Claude (Anthropic)

• Documentation quality: ⭐⭐⭐⭐ (Good, but not prominent)
• Setup instructions: Clear and concise
• Authentication: Simple - just ANTHROPIC_API_KEY
• Example workflows: 29 in repository
• Tool support: Full MCP support, all tools work

2. Copilot (GitHub)

• Documentation quality: ⭐⭐⭐⭐⭐ (Excellent, most detailed)
• Setup instructions: Very detailed with PAT creation guide
• Authentication: Complex - COPILOT_GITHUB_TOKEN with specific scopes
• Example workflows: 69 in repository
• Tool support: Full MCP support, all tools work

3. Codex (OpenAI)

• Documentation quality: ⭐⭐⭐ (Basic coverage)
• Setup instructions: Minimal but sufficient
• Authentication: Simple - just OPENAI_API_KEY
• Example workflows: 9 in repository
• Tool support: Full MCP support, all tools work

4. Custom Engines

• Documentation quality: ⭐⭐⭐⭐ (Good reference documentation)
• Setup instructions: Advanced users only
• Authentication: User-defined
• Example workflows: Few or none
• Tool support: User-controlled

Documentation Quality by Engine

Engine	Setup Docs	Examples	Auth Docs	Tool Docs	Overall Score
Claude	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐ (4/5)
Copilot	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐ (5/5)
Codex	⭐⭐⭐	⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐ (3/5)
Custom	⭐⭐⭐⭐	⭐	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐ (3/5)

Key Insight: The quality difference is primarily in prominence and detail, not in actual capability. Claude works just as well as Copilot, but Copilot documentation is more extensive.

---

Tool Availability Analysis

Tools Review

Analyzed tool compatibility across engines - EXCELLENT NEWS: All tools are engine-agnostic!

Engine-Agnostic Tools (All Work with Any Engine):

• ✅ edit: - File editing
• ✅ bash: - Shell commands
• ✅ github: - GitHub API operations (via MCP)
• ✅ web-fetch: - Web content fetching
• ✅ web-search: - Web search (engine-dependent for some, but supported)
• ✅ playwright: - Browser automation
• ✅ agentic-workflows: - Workflow introspection
• ✅ cache-memory: - Persistent storage
• ✅ repo-memory: - Repository memory
• ✅ Custom MCP servers - All work via MCP protocol

Engine-Specific Tools:

• NONE! No tools are locked to specific engines

Tool Compatibility:
The tools.md documentation (Line 8) states: "Some tools are available by default. All tools declared in imported components are merged into the final workflow."

Important Finding: The documentation does NOT state that tools require specific engines. This is correct - the MCP protocol ensures engine-agnostic tool access.

Recommendation: Add explicit callout in tools.md:

> [!NOTE]
> Engine Compatibility
> All tools work with Claude, Copilot, and Codex engines. The Model Context Protocol (MCP) 
> ensures consistent tool access regardless of your chosen AI engine.
```

---

## Authentication Requirements

### Current Documentation

Quick Start and Engines reference cover authentication for all engines:

**Covered Engines:**
- ✅ **Copilot** - Detailed instructions with PAT creation walkthrough (docs/src/content/docs/reference/engines.md, Lines 9-24)
- ✅ **Claude** - Clear instructions with API key creation (docs/src/content/docs/reference/engines.md, Lines 26-38)
- ✅ **Codex** - Basic instructions with API key creation (docs/src/content/docs/reference/engines.md, Lines 40-51)
- ✅ **Custom** - Configuration options documented (docs/src/content/docs/reference/custom-engines.md)

### Authentication Quality Assessment

**Copilot Authentication:**
- ⭐⭐⭐⭐⭐ Excellent - step-by-step with three IMPORTANT callouts
- Explains PAT scopes in detail
- Warns about common mistakes (selecting org instead of user)
- Shows exact CLI command for setting secret

**Claude Authentication:**
- ⭐⭐⭐⭐ Good - concise and clear
- Single URL for API key creation
- Exact CLI command shown
- Could benefit from: screenshot, quota discussion, common errors

**Codex Authentication:**
- ⭐⭐⭐ Basic - functional but minimal
- Single URL for API key creation
- Exact CLI command shown
- Could benefit from: usage limits, pricing note

### Missing for Claude Users

**What's documented:** ✅ Where to get API key, ✅ How to set secret, ✅ Secret name

**What could be added:**
1. **API key management best practices** - How to rotate keys, when to use separate keys per repo
2. **Usage tracking** - How to monitor Claude API usage from workflows
3. **Rate limits** - Claude API rate limits and how they affect workflows
4. **Cost estimation** - Typical cost per workflow run with Claude
5. **Troubleshooting** - Common Claude authentication errors

**Comparison to Copilot:** Copilot docs include warnings about common mistakes (e.g., "select your user account, NOT an organization"). Claude docs could benefit from similar practical guidance.

### Secret Names Reference

Documented secret names (all correct and findable):

| Engine | Secret Name | Documentation Location | Quality |
|--------|-------------|----------------------|---------|
| Copilot | `COPILOT_GITHUB_TOKEN` | engines.md, tokens.md, quick-start.mdx | ⭐⭐⭐⭐⭐ |
| Claude | `ANTHROPIC_API_KEY` | engines.md, quick-start.mdx | ⭐⭐⭐⭐ |
| Codex | `OPENAI_API_KEY` | engines.md | ⭐⭐⭐ |

**Observations:**
- All secret names are clearly documented
- Claude secret name is mentioned in 2+ places (good redundancy)
- Could add troubleshooting section: "If your workflow fails with 'authentication error', check your secret name matches exactly"

---

## Example Workflow Analysis

### Workflow Count by Engine

Analyzed `.github/workflows/*.md` files:

```
Total workflows:           147
Engine: copilot           69 (47%)
Engine: claude            29 (20%)
Engine: codex              9 (6%)
Unspecified/default       40 (27%)

Key Insights:

1. Claude has substantial representation - 29 workflows is significant
2. Copilot majority reflects development team usage - Not a technical limitation
3. Unspecified workflows likely work with any engine - 40 additional engine-agnostic examples
4. Codex is least represented - May indicate lower adoption

Example Distribution

Copilot Examples (69 workflows):

• Majority of workflows in repo
• Includes complex patterns: multi-repo, scheduled, PR-triggered
• Well-documented with inline comments
• Located throughout .github/workflows/

Claude Examples (29 workflows):

• Includes sophisticated workflows:
  • audit-workflows.md - Workflow analysis
  • blog-auditor.md - Content auditing
  • claude-code-user-docs-review.md - Documentation review (THIS workflow!)
  • cli-version-checker.md - Version checking
  • copilot-agent-analysis.md - Cross-engine analysis
  • And 24 more...
• Quality is HIGH - these are real production workflows
• Demonstrates Claude works well for complex tasks

Codex Examples (9 workflows):

• Smaller set but present
• Shows Codex is supported and functional

Quality Assessment

Copilot Examples:

• ⭐⭐⭐⭐⭐ Excellent quantity and diversity
• Cover all workflow patterns comprehensively
• Well-commented and explained

Claude Examples:

• ⭐⭐⭐⭐ Good quality, sufficient quantity
• Proves Claude is production-ready
• Could be more prominently featured in documentation

Visibility Issue:

• ❌ Claude examples not highlighted in Quick Start
• ❌ README doesn't feature Claude workflows
• ❌ Documentation pages don't link to Claude examples
• ✅ Examples DO exist and work well

Recommendation:
Add "Example Workflows by Engine" page showing:

• Top 3-5 Claude workflows with descriptions
• Top 3-5 Copilot workflows with descriptions
• Top 3-5 Codex workflows with descriptions
• Link from Quick Start: "See example workflows for your engine"

---

Recommended Actions

Priority 1: Critical Documentation Fixes

None Required! No blocking issues found for Claude users. The system works well.

Priority 2: Major Improvements

1. Clarify Prerequisites in Quick Start - High impact, low effort

   • Why it matters: First impression for new users
   • File: docs/src/content/docs/setup/quick-start.mdx (Line 17)
   • Change: Use table format to show engine alternatives clearly
   • Impact: Prevents initial confusion about Copilot requirement

2. Remove "Default" Language for Copilot - High visibility, medium effort

   • Why it matters: Creates perception of engine hierarchy
   • Files:
     • docs/src/content/docs/introduction/how-they-work.mdx (Line 18)
     • Multiple references in README.md
   • Change: Use neutral language: "Workflows support Claude, Copilot, and Codex engines"
   • Impact: Removes perception that Claude is second-class

3. Add Engine Selection Guidance - High value, medium effort

   • Why it matters: Users need help choosing engine
   • File: Create new docs/src/content/docs/guides/choosing-an-engine.md
   • Content:
     • When to use Claude (long context, reasoning, cost)
     • When to use Copilot (GitHub integration, subscription)
     • When to use Codex (enterprise, Azure)
     • Feature parity matrix
   • Impact: Empowers informed decision-making

Priority 3: Nice-to-Have Enhancements

1. Feature Claude Examples Prominently - Low effort, high visibility

   • Create "Featured Workflows" section in README
   • Show 1 Claude + 1 Copilot + 1 Codex example
   • Link to full catalog

2. Add "Engine Compatibility" Callout to Tools Page - Very low effort

   • Single callout box: "All tools work with all engines via MCP"
   • Eliminates any uncertainty

3. Enhance Claude Authentication Documentation - Medium effort

   • Match detail level of Copilot docs
   • Add common errors section
   • Include usage tracking guidance

4. Create Engine-Specific Quickstart Paths - High effort, high value

   • "Getting Started with Claude" page
   • "Getting Started with Copilot" page
   • "Getting Started with Codex" page
   • Each with engine-specific screenshots and flows

5. Alphabetize Engine References - Low effort, consistency

   • Use consistent ordering: alphabetical or neutral
   • Avoid always listing Copilot first

6. Add Visual Engine Indicators - Medium effort

   • Badges on example workflows showing engine
   • Filter on documentation site by engine
   • "Works with: 🤖 Claude | 🐙 Copilot | 🔮 Codex" indicators

---

Positive Findings

What Works Well

Claude Code users will be pleased to find:

• ✅ True engine-agnostic architecture - No vendor lock-in, clean MCP-based design
• ✅ Simple Claude authentication - Just ANTHROPIC_API_KEY, no complex scopes
• ✅ 29 production Claude workflows - Proves Claude works well in practice
• ✅ Interactive onboarding - add-wizard handles engine selection gracefully
• ✅ All tools work with Claude - Zero engine-specific tool restrictions
• ✅ Clear API key setup instructions - docs/src/content/docs/reference/engines.md is comprehensive
• ✅ MCP protocol ensures compatibility - Future-proof design
• ✅ No hidden Copilot dependencies - Architecture review confirmed zero hard dependencies
• ✅ CLI works identically across engines - All commands engine-agnostic
• ✅ Token documentation mentions Claude - ANTHROPIC_API_KEY well-documented
• ✅ Cost transparency - FAQ explains Claude usage billing
• ✅ Security model engine-agnostic - Sandbox, permissions, safe-outputs work same way

Special Praise:

• The engine: frontmatter field design is excellent - simple, clear, swappable
• The MCP tool architecture is exactly right - prevents engine lock-in
• The interactive add-wizard asking for engine selection shows thoughtful UX
• Having 29 Claude workflows in the repo shows real usage, not theoretical support

---

Conclusion

Can Claude Code Users Successfully Adopt gh-aw?

Answer: YES - with minor initial friction

Reasoning:

After comprehensive review, I found that gh-aw has excellent Claude support with a genuinely engine-agnostic architecture. The friction is primarily documentation presentation, not technical capability.

What Works:

• ✅ Architecture supports Claude equally with Copilot
• ✅ Authentication is simple and well-documented
• ✅ 29 example workflows prove Claude production-readiness
• ✅ All tools and features work with Claude
• ✅ No hidden dependencies on Copilot
• ✅ Interactive wizard handles engine selection

What Could Improve:

• ⚠️ Quick Start prerequisites could be clearer about alternatives
• ⚠️ "Default" language suggests Copilot primacy
• ⚠️ Claude examples not prominently featured
• ⚠️ Missing "when to choose Claude" guidance

The Experience:
A Claude user following the Quick Start will:

1. Read prerequisites and momentarily wonder if Copilot is required ⚠️
2. Run add-wizard and be prompted to select Claude ✅
3. Set up ANTHROPIC_API_KEY following clear instructions ✅
4. Successfully run workflows with Claude ✅

Bottom Line: Claude users CAN adopt gh-aw successfully. The documentation could be clearer upfront, but the actual experience is good once you get started.

Overall Assessment Score: 7.5/10

Breakdown:

• Architecture & Capability: 10/10 - Truly engine-agnostic, Claude fully supported
• Technical Documentation: 9/10 - Claude authentication and configuration clearly documented
• Onboarding Clarity: 5/10 - Copilot-first language creates initial confusion
• Example Diversity: 7/10 - 29 Claude workflows exist but aren't prominently featured
• Engine Parity: 10/10 - No feature gaps between engines

Scoring Rationale:

• High marks for technical quality and actual support
• Lower marks for documentation presentation and discovery
• The gap between capability (excellent) and clarity (good) drives improvement opportunities

Next Steps

For Documentation Team:

1. Quick Win: Add engine selection table to Quick Start prerequisites (30 minutes)
2. High Impact: Create "Choosing an Engine" guide (2-3 hours)
3. Medium Effort: Remove "default" language from key pages (1 hour)
4. Long Term: Feature Claude examples more prominently (ongoing)

For Claude Code Users:

If you're reading this and considering gh-aw:

• ✅ You can use it! Claude is fully supported
• ✅ Skip the confusion: Go straight to the add-wizard command
• ✅ Authentication is simple: Just create ANTHROPIC_API_KEY at console.anthropic.com
• ✅ Examples exist: Look in .github/workflows/ for 29 Claude workflows
• ✅ Get help: The #continuous-ai Discord channel is engine-agnostic

For Project Maintainers:

You've built an excellent engine-agnostic system. The improvements are about communicating that equality more clearly. Consider:

• Highlighting Claude as a first-class option earlier in docs
• Adding visual indicators (badges, filters) for engine diversity
• Creating engine-specific quickstart paths
• Featuring successful Claude workflows prominently

---

Appendix: Files Reviewed

Complete List of Documentation Files Analyzed

Core Documentation:

• README.md - Main repository introduction
• docs/src/content/docs/setup/quick-start.mdx - Primary onboarding guide
• docs/src/content/docs/introduction/how-they-work.mdx - Conceptual overview
• docs/src/content/docs/introduction/architecture.mdx - Security and design
• docs/src/content/docs/reference/tools.md - Tool configuration reference
• docs/src/content/docs/setup/cli.md - CLI command reference
• docs/src/content/docs/reference/engines.md - AI engine configuration
• docs/src/content/docs/reference/tokens.md - Authentication and tokens
• docs/src/content/docs/reference/frontmatter.md - Workflow configuration
• docs/src/content/docs/reference/faq.md - Frequently asked questions
• docs/src/content/docs/setup/creating-workflows.mdx - Workflow creation guide

Example Workflows Analyzed:

• Reviewed all 147 workflows in .github/workflows/
• Specifically examined 29 Claude-based workflows
• Analyzed engine distribution and patterns

Additional References:

• docs/src/content/docs/patterns/trialops.md - Testing patterns
• docs/src/content/docs/guides/ - Various guides (referenced but not fully read)
• .github/workflows/claude-code-user-docs-review.md - This workflow's source

---

Report Generated: Run ID 21783638289
Workflow: claude-code-user-docs-review
Engine Used: claude (eating our own dog food! 🐕)
Review Date: 2026-02-07
Reviewer Persona: Claude Code user (non-Copilot developer)

---

Discussion Tags

Suggested labels for this discussion:

• documentation
• user-experience
• engines
• claude
• onboarding
• feedback

---

Note: This was intended to be a discussion, but discussions could not be created due to permissions issues. This issue was created as a fallback.

AI generated by Claude Code User Documentation Review

• expires on Feb 14, 2026, 5:09 PM UTC

[github-actions]

This issue is being closed as outdated. A newer issue has been created: #14536

View newer issue

---

This action was performed automatically by the Claude Code User Documentation Review workflow.