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

> Learn how to test AI Berkshire skills by installing integration scripts and invoking slash commands via Codex or Claude Code to run agent workflows and generate markdown reports.

- Repository: [Xbt Lin/ai-berkshire](https://github.com/xbtlin/ai-berkshire)
- Tags: how-to-guide
- Published: 2026-07-08

---

**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`](https://github.com/xbtlin/ai-berkshire/blob/main/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`](https://github.com/xbtlin/ai-berkshire/blob/main/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`](https://github.com/xbtlin/ai-berkshire/blob/main/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`](https://github.com/xbtlin/ai-berkshire/blob/main/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:

```bash
./scripts/install-codex-skills.sh

```

This script executes [`scripts/sync-codex-skills.py`](https://github.com/xbtlin/ai-berkshire/blob/main/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:

```bash
./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`:

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

```

This command loads [`skills/financial-data.md`](https://github.com/xbtlin/ai-berkshire/blob/main/skills/financial-data.md), executes the workflow, and produces [`financial-data-600519.SS.md`](https://github.com/xbtlin/ai-berkshire/blob/main/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:

```bash
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`](https://github.com/xbtlin/ai-berkshire/blob/main/investment-team-000858.SZ.md).

### Batch Processing Skills

Test screening capabilities against multiple securities using the watchlist functionality:

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

```

This processes the JSON watchlist defined in [`data/watchlist.json`](https://github.com/xbtlin/ai-berkshire/blob/main/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`](https://github.com/xbtlin/ai-berkshire/blob/main/investment-research-AAPL.md) or [`news-pulse-PDD.md`](https://github.com/xbtlin/ai-berkshire/blob/main/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):

```bash
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:

```python
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`](https://github.com/xbtlin/ai-berkshire/blob/main/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`](https://github.com/xbtlin/ai-berkshire/blob/main/scripts/install-codex-skills.sh) (for Codex) or [`scripts/install-claude-commands.sh`](https://github.com/xbtlin/ai-berkshire/blob/main/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`](https://github.com/xbtlin/ai-berkshire/blob/main/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`](https://github.com/xbtlin/ai-berkshire/blob/main/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`](https://github.com/xbtlin/ai-berkshire/blob/main/scripts/sync-codex-skills.py) to regenerate the Codex packages, or re-run [`scripts/install-claude-commands.sh`](https://github.com/xbtlin/ai-berkshire/blob/main/scripts/install-claude-commands.sh) to update Claude Code global commands. The changes take effect immediately after the client reloads its skill cache.