Getting it into your agent
It runs from inside its repository, so the clone comes first — what it calls does not travel with the file alone.
git clone --depth 1 https://github.com/prime-radiant-inc/greenfieldnpx agentmods add skills/prime-radiant-inc/greenfield/source-analysisWrote this? Show the measurements
A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.
[](https://agentmods.dev/skills/prime-radiant-inc/greenfield/source-analysis)<a href="https://agentmods.dev/skills/prime-radiant-inc/greenfield/source-analysis"><img src="https://agentmods.dev/badge/skills/prime-radiant-inc/greenfield/source-analysis.svg" alt="Measured on agentmods" height="20"></a>What it costs to keep this loaded
Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.
| Model | Per session | Once invoked |
|---|---|---|
| Fable 5.1 | $0.00052 | $0.10265 |
| Opus 5 | $0.00026 | $0.05132 |
| Sonnet 5 | $0.00010 | $0.02053 |
| Haiku 4.5 | $0.00005 | $0.01026 |
Grade A, and why
source-analysis scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 7d ago.
A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.
Nothing flagged
None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.
How it starts
The opening of the file, as written. The whole thing — 1,052 lines — stays where its author put it; the contents beside it link to each section on GitHub.
Source Analysis Methodology
Extract behavioral intelligence from source code. Decompose the codebase into analyzable units, then systematically analyze each unit for behavioral claims with full provenance.
When to Use This Mode
Source analysis activates when:
- The discovery inventory identifies source code files at the target path
- Any source code needs behavioral analysis (any language, bundled or not)
- Decompiled output exists at
workspace/raw/source/decompiled/
General Approach
Source analysis takes three shapes depending on what the target looks like:
- Source tree — a repository with a package manifest and conventional directory layout (Python, Rust, Go, Swift, Java, Node/TS, C++, etc.). Follow the Source Tree Pipeline below.
- Bundle — a single-file minified or packed artifact (JavaScript bundle, Electron asar, webpack/esbuild output). Follow the Bundle Pipeline below.
- Decompiled binary — a compiled artifact where source isn't directly available. Decompile first via the Decompilation Path, then analyze the decompiled output using whichever of the above shapes fits.
Regardless of shape, the pipeline follows the same logical steps:
- Assess the source. What language? How is it organized? How large is it?
- Decompose into analyzable units. Use the language's natural boundaries (modules, packages, files) when they exist. Split bundled artifacts into chunks when they don't.
- Analyze each unit exhaustively. Read every line. Identify every function, method, class. Understand what each does behaviorally.
- Extract behavioral specifications. Write what the code DOES (observable behavior), not how it's structured (implementation details). Every claim gets a provenance citation.
Phases 6-8 (per-unit analysis, per-function deep analysis, targeted extraction) are shape-agnostic and apply to all three paths.
Decompilation Path
When source code isn't directly available, decompile binaries into structured source before analysis.
What this file has done since we first saw it
Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.
- 7d ago First seen · 1,052 lines · 52 tokens per session scan A 6dbb3abafc4b
source-analysis is a skill published in the GitHub repository prime-radiant-inc/greenfield (271 stars, last pushed 1mo ago), licensed Apache-2.0. It adds 52 tokens to every session and 10,265 once invoked, about $0.0003 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-30.
Other skills, from other repositories
release-it
Build production-ready systems with stability patterns: circuit breakers, bulkheads, timeouts, and retry logic. Use when the user mentions "production outage", "circuit breaker", "deployment pipeline", "chaos engineering", "retry storm", "health checks", "my service keeps crashing", "prevent cascading failures", or…
tidewave-integration
Tidewave MCP runtime tools — debugging, smoke testing, live state inspection, SQL queries, hex docs. Use when evaluating code in a running Phoenix app.
Reverse Engineering & Binary Analysis
Binary analysis, assembly interpretation, disassembly, decompilation, firmware RE, and protocol reverse engineering.
debug
Interactive debugging workflow with hypothesis-driven probe loop. Use when: unknown bugs, script errors, silent failures, troubleshooting. Not for: known bugs (use bug-fix), GitHub issue analysis (use issue-analyze), code understanding (use code-explore). Output: debug report with probe journal + root cause + fix.
git-investigate
Git history investigation. Use when: tracking code changes, finding where bugs were introduced, root cause analysis. Not for: code exploration (use code-explore), issue analysis (use issue-analyze). Output: history trace + root cause report.
simplify
Wrap-up refactoring — simplify code, eliminate duplication, preserve behavior.