How to Test the Different Skills in AI Berkshire: A Complete Guide

You test AI Berkshire skills by installing the client integration scripts, then invoking slash commands through Codex or Claude Code to execute agent workflows and generate structured markdown reports.

AI Berkshire packages investment research capabilities as modular skills—self-contained markdown definitions that orchestrate agents and tools. To test the different skills in ai-berkshire, you interface with the repository through either the Codex or Claude Code client layers, which parse the canonical skill definitions in skills/*.md and execute the prescribed workflows. Each skill invocation produces a verifiable research report, allowing you to validate functionality without writing custom test code.

Understanding the Skill Architecture

AI Berkshire organizes capabilities into three distinct layers that work together during skill execution.

The Skill Layer

The Skill Layer serves as the single source of truth. Each skill resides as a markdown file in the skills/ directory (e.g., skills/investment-research.md). These files define the command syntax, agent orchestration logic, and output formatting that clients consume.

The Agent and Tool Layers

Beneath the skills, an optional Agent Layer spins up specialized research agents (such as the Buffett, Munger, Duan Yongping, and Li Lu perspectives for team skills). The Tool Layer provides Python utilities like tools/financial_rigor.py that handle precise financial calculations and cross-validation of data sources.

Client Integration Points

Two client integrations expose these skills to end users:

• Codex: Uses scripts/install-codex-skills.sh to generate skill packages in codex-skills/*/SKILL.md, then registers them under ~/.codex/skills
• Claude Code: Uses scripts/install-claude-commands.sh to copy global commands to ~/.claude/commands, enabling invocation via claude /skill-name

Both clients share the same underlying skill definitions, ensuring consistent behavior regardless of which interface you choose to test.

Installing the Client Layers

Before testing any skills, you must install the appropriate client integration from the repository root.

Codex Installation

Run the Codex installer to generate and register skill packages:

./scripts/install-codex-skills.sh

This script executes scripts/sync-codex-skills.py to transform the markdown files in skills/ into Codex-compatible packages and places them in your local Codex configuration directory.

Claude Code Installation

For Claude Code users, run the command installer:

./scripts/install-claude-commands.sh

This copies the skill command definitions to ~/.claude/commands, making them available as global slash commands.

Note: After installation, restart your terminal or the Codex daemon to ensure the new skills are loaded into the client environment.

Testing Individual Skills

Once installed, you test skills by invoking them with appropriate arguments. The client parses the skill definition, loads required agents, calls utility functions, and writes a markdown report to your current directory.

Single-Agent Skills

Test foundational data gathering with single-agent skills like /financial-data:

codex run /financial-data --ticker 600519.SS

This command loads skills/financial-data.md, executes the workflow, and produces financial-data-600519.SS.md containing cross-validated balance-sheet data from Eastmoney and Xueqiu sources.

Team-Based Skills

Test collaborative research capabilities using team skills that launch multiple parallel agents:

claude /investment-team 000858.SZ

This invokes the investment team skill, which spins up four master-perspective agents (Buffett, Munger, Duan Yongping, Li Lu). Each agent produces a draft analysis before the team-lead synthesizes them into investment-team-000858.SZ.md.

Batch Processing Skills

Test screening capabilities against multiple securities using the watchlist functionality:

codex run /quality-screen --watchlist data/watchlist.json

This processes the JSON watchlist defined in data/watchlist.json and generates individual research reports for each ticker, validating the batch processing logic of the skill layer.

Validating Skill Execution

After invoking a skill, verify that the execution pipeline functioned correctly by inspecting outputs and using diagnostic flags.

Inspecting Output Files

Each skill writes a structured markdown report named after the skill and ticker (e.g., investment-research-AAPL.md or news-pulse-PDD.md). Open these files to verify:

• Data completeness from the tool layer
• Agent reasoning quality (for team skills)
• Proper formatting and cross-references

Using Dry-Run Mode

For rapid validation without incurring API costs or network latency, use the --dry-run flag (supported by Codex):

codex run /quality-screen --watchlist data/watchlist.json --dry-run

This flag parses the skill definition and validates argument processing without executing the heavy data-fetching steps or agent calls, making it ideal for CI pipelines and quick smoke tests.

Automated Testing Approaches

For systematic validation of all 19+ skills defined in the repository, use a bulk testing harness that exercises each skill definition.

Run this Python script from the repository root to perform a dry-run validation across all skills:

import glob, subprocess, os

skills = glob.glob('skills/*.md')
for s in skills:
    name = os.path.splitext(os.path.basename(s))[0]
    print(f'🧪 Testing {name}')
    subprocess.run(['codex', 'run', f'/{name}', '--dry-run'], check=False)

This approach validates that each markdown file in skills/ correctly parses and that the client can locate the associated tool dependencies, such as tools/financial_rigor.py, without executing the full research workflow.

Summary

• AI Berkshire defines skills as markdown files in skills/*.md, which serve as the single source of truth for research capabilities.
• Install client integrations using scripts/install-codex-skills.sh (for Codex) or scripts/install-claude-commands.sh (for Claude Code).
• Test skills by invoking them with ticker arguments: codex run /skill-name --ticker SYMBOL or claude /skill-name SYMBOL.
• Validate outputs by inspecting the generated markdown reports in your working directory.
• Use --dry-run flags and automated Python scripts to test skill parsing without executing expensive data-fetching operations.

Frequently Asked Questions

How do I know if a skill is working correctly?

A functioning skill produces a markdown report file in your current directory named after the skill and ticker (e.g., investment-research-AAPL.md). If the file generates without errors and contains structured data or analysis, the skill exercised the tool layer and agent layer correctly. Check the file content for cross-validated financial data or multi-perspective analysis to confirm deep execution.

What is the difference between testing single-agent and team skills?

Single-agent skills like /financial-data invoke one research pipeline and complete faster, producing straightforward data reports. Team skills like /investment-team launch multiple parallel agents (four master perspectives) that each generate draft analyses before synthesis, creating more complex output files. Both follow the same testing pattern—invoke with a ticker argument and inspect the output—but team skills validate the orchestration layer in scripts/sync-codex-skills.py more extensively.

Can I test skills without making API calls or fetching live data?

Yes. Use the --dry-run flag with Codex commands to validate skill parsing and argument handling without executing network requests or agent calls. For example: codex run /investment-research --ticker AAPL --dry-run. This tests the integration between the skill definition and the client layer while skipping the tool layer execution.

Where are the skill definitions stored and how do I modify them?

The canonical skill definitions reside in skills/*.md at the repository root. When you modify these files, run scripts/sync-codex-skills.py to regenerate the Codex packages, or re-run scripts/install-claude-commands.sh to update Claude Code global commands. The changes take effect immediately after the client reloads its skill cache.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}