Analyzes URLs to see if they align with project goals and automates GitHub issue creation based on a verdict.

Install

mkdir -p .claude/skills/scout && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/13590" && unzip -o skill.zip -d .claude/skills/scout && rm skill.zip

Installs to .claude/skills/scout

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Analyze external URL to evaluate fit with oh-my-customcodex project and auto-create GitHub issue with verdict
109 charsno explicit “when” trigger
Intermediate

Key capabilities

  • Analyze external URLs for project fit
  • Categorize external resources into INTERNALIZE, INTEGRATE, or SKIP
  • Create GitHub issues with structured verdicts and labels
  • Fetch and summarize web page content from a given URL
  • Load project philosophy and existing skills for context

How it works

The skill fetches and summarizes content from an external URL, loads the project's philosophy and existing skills, then analyzes the content against predefined dimensions to determine its fit. Finally, it creates a GitHub issue with a structured verdict.

Inputs & outputs

You give it
An external URL to be analyzed.
You get back
A GitHub issue with a structured verdict (INTERNALIZE, INTEGRATE, or SKIP), priority, rationale, and recommendations.

When to use scout

  • Evaluate new tech blog content
  • Check if library fits project
  • Audit external tool relevance

About this skill

/scout — External Link Analysis

Analyze an external URL (tech blog, tool, library, methodology) to evaluate its fit with the oh-my-customcodex project and auto-create a GitHub issue with a structured verdict.

Sensitive-Path Delegation

Sensitive-path compatibility note: if this skill delegates work that touches .claude/**, .claude/outputs/**, templates/.claude/**, or read-only measurements of those paths, keep .codex/** edits on the normal Codex path. On Claude Code v2.1.121+ with bypassPermissions, direct writes to .claude/skills/, .claude/agents/, and .claude/commands/ are allowed; on v2.1.126+ that extends to broader protected paths. Only use /tmp/{skill}-{timestamp}.md as a legacy fallback when the target runtime is older or still prompts.

Usage

/scout <url>
/scout https://news.hada.io/topic?id=27673
/scout https://github.com/user/repo

Verdict Taxonomy

VerdictMeaningLabelFollow-up
INTERNALIZEAligns with project philosophy; should become a skill/agent/guidescout:internalize + P1/P2/P3/research or direct implementation
INTEGRATEUseful but best kept as external dependencyscout:integrate + P2/P3Plugin/MCP integration review
SKIPIrrelevant or duplicates existing functionalityscout:skipIssue created then closed

Pre-flight Guards

Pre-flight Execution Checklist (MANDATORY before Phase 1)

Both guards MUST be executed before entering Phase 1. Skipping either guard is a workflow violation.

  • Guard 1: URL Validity check passed (abort if invalid)
  • Guard 2: Duplicate Scout check passed (warn and confirm if duplicate found)

Proceed to Phase 1 only after both checkboxes are satisfied.

Guard 1: URL Validity (GATE)

Before any work, validate the URL:

# Check URL is syntactically valid
echo "$URL" | grep -qE '^https?://'

If invalid: [Pre-flight] GATE: Invalid or unreachable URL. Please check and retry. — abort.

Guard 2: Duplicate Scout (WARN)

Search existing GitHub issues for prior scout reports on the same URL domain:

DOMAIN=$(echo "$URL" | sed 's|https\?://||' | cut -d'/' -f1)
gh issue list --state all --label "scout:internalize,scout:integrate,scout:skip" \
  --json number,title,body --jq ".[] | select(.body | contains(\"$DOMAIN\"))" 2>/dev/null

If found: [Pre-flight] WARN: Similar URL already scouted in issue #N. Proceed anyway? [Y/n]

Why mandatory? Guard 2 생략으로 인해 동일 도메인 중복 scout 이슈가 생성된 사례 발생. 중복 triage 낭비를 방지하기 위해 Pre-flight 체크리스트로 승격.

Display Format

Before execution, show the plan:

[Scout] {url}
├── Phase 1: 콘텐츠 수집 및 요약
├── Phase 2: 프로젝트 철학 로드
├── Phase 3: 적합성 분석 (frontier/medium)
└── Phase 4: 이슈 생성

예상: ~1분 | 비용: ~$0.5-1.5
실행하시겠습니까? [Y/n]

암묵 승인 시 필수: "되면 /scout으로 보고", "실행해줘" 등 묵시적 승인인 경우에도 위 plan 요약을 반드시 1줄 이상 표시한 뒤 진행한다. plan 표시 없이 바로 Phase 1으로 진입하지 않는다.

Workflow

Phase 1: Fetch & Summarize

  1. WebFetch(url) — retrieve page content
  2. Extract core information:
    • Title and purpose
    • Key technology / methodology
    • Approach and principles
  3. If fetch fails — report error, abort

External quantitative-fact source tagging (#1466): WebFetch가 산출한 구체적 정량 주장(benchmark 수치, table 값, metric)은 이슈 본문에 WebFetch-derived (unverified)로 태깅한다 — 검증된 사실로 제시하지 않는다. WebFetch 캐시/요약은 독립 ground-truth가 아니므로, load-bearing 수치는 primary PDF/원문으로 1회 검증하거나 명시적으로 unverified로 표기한다. (R020 Read-Before-Characterize, R023 Verifier Ground-Truth)

Phase 2: Load Project Philosophy

  1. Read(AGENTS.md) — extract architecture philosophy:
    • Compilation metaphor (source -> build -> artifact)
    • Separation of concerns (R006)
    • Dynamic agent creation ("no expert? create one")
    • Skill/agent/guide/rule structure
  2. Read(README.md) — extract project overview and component inventory
  3. Glob(.codex/skills/*/SKILL.md) — list existing skills for overlap detection

Phase 3: Fit Analysis

Spawn 1 frontier/medium agent with the following analysis prompt.

Claude compatibility Agent calls only (R010 “Delegated Permission Ownership”): Pass mode: "bypassPermissions" when the active Claude session uses bypass permissions. Native Codex spawn_agent has no mode parameter; use the installed agent_type and active Codex runtime permissions instead.

Inputs:

  • Fetched content summary (Phase 1)
  • Project philosophy context (Phase 2)
  • Existing skill list (Phase 2)

Analysis dimensions:

DimensionQuestion
Philosophy alignmentDoes it match the compilation metaphor, separation of concerns, "create experts on demand"?
Technical fitDoes it complement or overlap with existing skills/agents/guides?
Integration effortHow much work to internalize vs. use externally?
Value propositionWhat concrete benefit does it bring to the project?

Agent prompt template:

You are a project fit analyst. Given:

1. External content summary:
{phase1_summary}

2. Project philosophy:
{phase2_philosophy}

3. Existing skills ({skill_count} total):
{skill_list}

Analyze the external content against the project philosophy across 4 dimensions:
- Philosophy alignment
- Technical fit (overlap with existing skills?)
- Integration effort (XS/S/M/L)
- Value proposition

Return a structured verdict:
- verdict: INTERNALIZE | INTEGRATE | SKIP
- priority: P1 | P2 | P3
- rationale: 2-3 sentences
- philosophy_table: criterion/fit/rationale for each dimension
- recommendation: specific integration plan or skip reason
- next_steps: 2-3 actionable items
- IMPORTANT: Write all analysis output in Korean. Technical terms, code references, label names, and skill/agent names stay in English.
- escalation: true/false (INTERNALIZE + M/L effort = true)

Output: Structured verdict with rationale.

Phase 4: Issue Creation

NOTE: Phase 4 is normally handled by the orchestrator with gh issue create. If issue creation is delegated through a Claude compatibility Agent call, pass mode: "bypassPermissions" only when that Claude session uses bypass permissions. Native Codex spawn_agent never accepts mode.

  1. Ensure scout labels exist (defensive, idempotent):
gh label create "scout:internalize" --color "0E8A16" --description "Scout: should be internalized" 2>/dev/null || true
gh label create "scout:integrate" --color "1D76DB" --description "Scout: keep as external" 2>/dev/null || true
gh label create "scout:skip" --color "D4C5F9" --description "Scout: skip" 2>/dev/null || true
  1. Create GitHub issue:
gh issue create \
  --title "[scout:{verdict}] {content_title}" \
  --label "scout:{verdict},P{n}" \
  --body "{issue_body}"
  1. If verdict is SKIP: auto-close the issue:
gh issue close {number} -c "Auto-closed: scout verdict is SKIP"

Issue Body Template

## Scout 리포트: {title}

**출처**: {url}
**판정**: {INTERNALIZE / INTEGRATE / SKIP}
**우선순위**: {P1 / P2 / P3}

## 요약
{외부 콘텐츠에 대한 2-3문장 요약}

## 프로젝트 철학 정합성
| 기준 | 적합 | 근거 |
|------|------|------|
| Compilation metaphor | {check/cross} | {설명} |
| Separation of concerns (R006) | {check/cross} | {설명} |
| Dynamic agent creation | {check/cross} | {설명} |
| 기존 스킬 중복 | {check/cross} | {중복 스킬 목록} |

## 권장 사항
{구체적 통합 계획 — 어떤 skill/agent/guide를 생성할지, 또는 건너뛰는 이유}

## 다음 단계
- [ ] {후속 조치 1}
- [ ] {후속 조치 2}

---
`/scout`에 의해 생성됨

Escalation

When verdict is INTERNALIZE and integration effort is M or L:

[Advisory] 심층 분석 권장.
└── 실행 검토: /research {url}

Result Display

[Scout 완료] {title}
├── 판정: {INTERNALIZE / INTEGRATE / SKIP}
├── 우선순위: {P1 / P2 / P3}
├── 이슈: #{number}
└── 에스컬레이션: {/research 권장 | 없음}

Capability Routing

PhaseLane / EffortRationale
Phase 1 (Fetch)orchestratorSimple WebFetch, no agent needed
Phase 2 (Load)orchestratorSimple Read/Glob, no agent needed
Phase 3 (Analysis)frontier/mediumBalanced reasoning for fit analysis
Phase 4 (Issue)orchestratorgh issue create via Bash

Integration

RuleHow
R009Single agent in Phase 3 — no parallelism needed
R010Orchestrator manages phases 1/2/4; analysis delegated to frontier/medium agent in Phase 3
R015Display scout plan before execution (Display Format section)

When NOT to Use

ScenarioBetter Alternative
Deep multi-source research/research <url>
Internal project analysis/omcustomcodex:analysis
Known tool evaluationDirect agent conversation
Bulk URL analysis (5+)/research with URL list

Differences from /research

Aspect/scout/research
PurposeQuick fit evaluationDeep multi-dimensional analysis
Teams1 agent10 teams
CostRuntime-dependent, one analysis roleRuntime-dependent, bounded team workflow
Duration1-2 min10-20 min
OutputIssue with verdictFull report with ADOPT/ADAPT/AVOID
WhenFirst contact with new linkDeep dive after scout recommends

When not to use it

  • When analyzing internal project components
  • When evaluating a known tool directly through agent conversation

Limitations

  • Requires URL validity check before proceeding
  • Requires a duplicate scout check to warn about existing issues
  • If fetch fails, the process reports an error and aborts

How it compares

This skill automates the evaluation of external resources and the creation of GitHub issues with structured verdicts, providing a standardized and traceable process compared to manual assessment and issue creation.

Compared to similar skills

scout side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
scout (this skill)02moReviewIntermediate
competitive-intel22moNo flagsAdvanced
github-issues03moNo flagsBeginner
discovery-workflow04moNo flagsIntermediate

Try saying

Example prompts that trigger this skill in your AI assistant.

Search skills

Search the agent skills registry