Skip to content
cccskills
FreePublished on GitHub

code-maturity-assessor

Assesses smart contract and blockchain codebases against Trail of Bits’ nine-category maturity framework. Produces evidence-backed ratings covering areas such as arithmetic, access controls, documentation, and testing, plus a prioritized improvement roadmap with effort estimates.

OriginalShow the original description

Systematic code maturity assessment using Trail of Bits' 9-category framework. Analyzes codebase for arithmetic safety, auditing practices, access controls, complexity, decentralization, documentation, MEV risks, low-level code, and testing, then produces a scorecard with evidence-based ratings and a priority-ordered roadmap. Use when assessing or scoring the maturity of a smart contract or blockchain codebase, producing a maturity scorecard or evaluation, or judging how mature, well-tested, or well-documented such a project is against a rubric.

See how to install

Good for

  • Assessing the maturity of a smart contract project
  • Identifying gaps in tests and documentation
  • Reviewing access controls and operational practices together
  • Planning improvements by priority and estimated effort

Files included (6)

  • SKILL.md7.1 KB
  • agents/openai.yaml242 B
  • assets/trail-of-bits-mark.svg3.0 KB
  • resources/ASSESSMENT_CRITERIA.md9.6 KB
  • resources/EXAMPLE_REPORT.md7.4 KB
  • resources/REPORT_FORMAT.md726 B

SKILL.md (original)

Review the instructions the agent will receive before you install.

Code Maturity Assessor

Purpose

Systematically assesses codebase maturity using Trail of Bits' 9-category framework. Provides evidence-based ratings and actionable recommendations.

Framework: Building Secure Contracts - Code Maturity Evaluation v0.1.0


How This Works

Phase 1: Discovery

Explores the codebase to understand:

  • Project structure and platform
  • Contract/module files
  • Test coverage
  • Documentation availability

Phase 2: Analysis

For each of 9 categories, I'll:

  • Search the code for relevant patterns
  • Read key files to assess implementation
  • Present findings with file references
  • Ask clarifying questions about processes I can't see in code
  • Determine rating based on criteria

Phase 3: Report

Generates:

  • Executive summary
  • Maturity scorecard (ratings for all 9 categories)
  • Detailed analysis with evidence
  • Priority-ordered improvement roadmap

Rating System

  • Missing (0): Not present/not implemented
  • Weak (1): Several significant improvements needed
  • Moderate (2): Adequate, can be improved
  • Satisfactory (3): Above average, minor improvements
  • Strong (4): Exceptional, only small improvements possible

Rating Logic:

  • ANY "Weak" criteria → Weak
  • NO "Weak" + SOME "Moderate" unmet → Moderate
  • ALL "Moderate" + SOME "Satisfactory" met → Satisfactory
  • ALL "Satisfactory" + exceptional practices → Strong

The 9 Categories

I assess 9 comprehensive categories covering all aspects of code maturity. For detailed criteria, analysis approaches, and rating thresholds, see ASSESSMENT_CRITERIA.md.

Quick Reference:

1. ARITHMETIC

  • Overflow protection mechanisms
  • Precision handling and rounding
  • Formula specifications
  • Edge case testing

2. AUDITING

  • Event definitions and coverage
  • Monitoring infrastructure
  • Incident response planning

3. AUTHENTICATION / ACCESS CONTROLS

  • Privilege management
  • Role separation
  • Access control testing
  • Key compromise scenarios

4. COMPLEXITY MANAGEMENT

  • Function scope and clarity
  • Cyclomatic complexity
  • Inheritance hierarchies
  • Code duplication

5. DECENTRALIZATION

  • Centralization risks
  • Upgrade control mechanisms
  • User opt-out paths
  • Timelock/multisig patterns

6. DOCUMENTATION

  • Specifications and architecture
  • Inline code documentation
  • User stories
  • Domain glossaries

7. TRANSACTION ORDERING RISKS

  • MEV vulnerabilities
  • Front-running protections
  • Slippage controls
  • Oracle security

8. LOW-LEVEL MANIPULATION

  • Assembly usage
  • Unsafe code sections
  • Low-level calls
  • Justification and testing

9. TESTING & VERIFICATION

  • Test coverage
  • Fuzzing and formal verification
  • CI/CD integration
  • Test quality

For complete assessment criteria including what I'll analyze, what I'll ask you, and detailed rating thresholds (WEAK/MODERATE/SATISFACTORY/STRONG), see ASSESSMENT_CRITERIA.md.


Example Output

When the assessment is complete, you'll receive a comprehensive maturity report including:

  • Executive Summary: Overall score, top 3 strengths, top 3 gaps, priority recommendations
  • Maturity Scorecard: Table with all 9 categories rated with scores and notes
  • Detailed Analysis: Category-by-category breakdown with evidence (file:line references)
  • Improvement Roadmap: Priority-ordered recommendations (CRITICAL/HIGH/MEDIUM) with effort estimates

For a complete example assessment report, see EXAMPLE_REPORT.md.


Assessment Process

When invoked, I will:

  1. Explore codebase

    • Find contract/module files
    • Identify test files
    • Locate documentation
  2. Analyze each category

    • Search for relevant code patterns
    • Read key implementations
    • Assess against criteria
    • Collect evidence
  3. Interactive assessment

    • Present my findings with file references
    • Ask about processes I can't see in code
    • Discuss borderline cases
    • Determine ratings together
  4. Generate report

    • Executive summary
    • Maturity scorecard table
    • Detailed category analysis with evidence
    • Priority-ordered improvement roadmap

Rationalizations (Do Not Skip)

RationalizationWhy It's WrongRequired Action
"Found some findings, assessment complete"Assessment requires evaluating ALL 9 categoriesComplete assessment of all 9 categories with evidence for each
"I see events, auditing category looks good"Events alone don't equal auditing maturityCheck logging comprehensiveness, testing, incident response processes
"Code looks simple, complexity is low"Visual simplicity masks composition complexityAnalyze cyclomatic complexity, dependency depth, state machine transitions
"Not a DeFi protocol, MEV category doesn't apply"MEV extends beyond DeFi (governance, NFTs, games)Verify with transaction ordering analysis before declaring N/A
"No assembly found, low-level category is N/A"Low-level risks include external calls, delegatecall, inline assemblySearch for all low-level patterns before skipping category
"This is taking too long"Thorough assessment requires time per categoryComplete all 9 categories, ask clarifying questions about off-chain processes
"I can rate this without evidence"Ratings without file:line references = unsubstantiated claimsCollect concrete code evidence for every category assessment
"User will know what to improve"Vague guidance = no actionProvide priority-ordered roadmap with specific improvements and effort estimates

Report Format

For detailed report structure and templates, see REPORT_FORMAT.md.

Structure:

  1. Executive Summary

    • Project name and platform
    • Overall maturity (average rating)
    • Top 3 strengths
    • Top 3 critical gaps
    • Priority recommendations
  2. Maturity Scorecard

    • Table with all 9 categories
    • Ratings and scores
    • Key findings notes
  3. Detailed Analysis

    • Per-category breakdown
    • Evidence with file:line references
    • Gaps and improvement actions
  4. Improvement Roadmap

    • CRITICAL (immediate)
    • HIGH (1-2 months)
    • MEDIUM (2-4 months)
    • Effort estimates and impact

Ready to Begin

Estimated Time: 30-40 minutes

I'll need:

  • Access to full codebase
  • Your knowledge of processes (monitoring, incident response, team practices)
  • Context about the project (DeFi, NFT, infrastructure, etc.)

Let's assess this codebase!

Reviews

No reviews yet. Tell others what you thought.

Comments

No login needed. Share how it worked for you, ask a question, or note where it did not run.

No comments yet. Be the first to write one.

Comments are published right away. Do not include personal information such as email addresses or phone numbers. Up to 2 URLs.

0 / 1,000 characters

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

More skills from this repository

Build and test code with AddressSanitizer, a tool that detects invalid memory access during execution. Configure checks for C/C++ and unsafe Rust, investigate crash reports, and adjust settings for fuzzing, or testing with generated inputs.

  • Detect memory errors while fuzzing C/C++
  • Test unsafe Rust and calls to external libraries
  • Interpret an ASan crash report
trailofbits/skills7.6KUpdated Oct 16, 2026

aflpp

FreeSummary

Sets up AFL++ to test C/C++ programs with varied generated inputs, a technique called fuzzing. Covers running tests across CPU cores, monitoring progress, reducing input collections, and reproducing crashes for investigation.

  • Running C/C++ fuzzing across multiple CPU cores
  • Exploring further after libFuzzer progress stalls
  • Monitoring fuzzing progress and stability
trailofbits/skills7.6KUpdated Oct 16, 2026

Audits GitHub Actions workflows that run AI coding agents. Traces how attacker-controlled content reaches prompts, checks permissions and sandbox settings, and reports evidence, severity, and fixes for prompt injection and related configuration risks.

  • Reviewing workflows that run AI coding agents
  • Tracing issue and PR content into agent prompts
  • Checking sandbox settings and user allowlists
trailofbits/skills7.6KUpdated Oct 16, 2026

Reviews Algorand smart contracts written in TEAL or PyTeal for 11 vulnerability patterns. Produces a complete coverage table and findings with code references, severity ratings, and suggested fixes, with optional automated checks using Tealer.

  • Security checks before an Algorand contract audit
  • Reviewing TEAL or PyTeal transaction validation
  • Verifying fixes for reported vulnerabilities
trailofbits/skills7.6KUpdated Oct 16, 2026

atheris

FreeSummary

Set up Atheris to test Python code and C extensions with automatically varied inputs. It guides test harness creation, coverage tracking to explore more code, and AddressSanitizer setup for finding memory errors.

  • Fuzzing a Python package or parser
  • Investigating memory corruption in Python C extensions
  • Turning raw bytes into typed test arguments
trailofbits/skills7.6KUpdated Oct 16, 2026

Connect static analysis results and human audit notes to a Trailmark code graph. Group findings by severity and compare them with input flow, impact, and privilege boundaries to prioritize investigation and understand findings in their code context.

  • Connecting Semgrep or CodeQL results to code structure
  • Combining human audit notes with automated findings
  • Prioritizing findings using input flow and impact
trailofbits/skills7.6KUpdated Oct 16, 2026

See all skills by trailofbits

Report a problem with this skill