How Configurations Are Managed in AI Berkshire: A Complete Guide

AI Berkshire manages configurations through a decentralized architecture utilizing GitHub issue templates, command-line arguments, JSON data files, and environment variables rather than a centralized configuration file.

The xbtlin/ai-berkshire repository employs a lightweight, code-proximate approach to settings. Instead of relying on monolithic .env or .ini files, configurations are managed in AI Berkshire through specific patterns that keep settings transparent, version-controlled, and close to the logic that consumes them.

Configuration Patterns in AI Berkshire

GitHub Issue Templates

The repository uses YAML-based configuration for GitHub's issue interface. The .github/ISSUE_TEMPLATE/config.yml file defines custom issue forms and required fields that GitHub renders directly in the web interface. This configuration is read natively by GitHub and is not consumed by any Python runtime code within the repository.

Command-Line Interface Configuration

Scripts expose operational parameters through explicit command-line flags using Python's built-in argparse module. In scripts/sync-codex-skills.py, the code instantiates argparse.ArgumentParser to define flags such as --check, allowing users to toggle behavior at runtime without modifying source files.

Data-Driven Configuration

Static datasets serve as configuration sources for analysis tools. The repository stores watchlists and fundamental data as JSON or CSV files in the data/ directory. Tools like those referencing data/watchlist.json load these settings using json.load(), treating data files as configuration sources that can be updated independently of the codebase.

Runtime Environment Variables

Secrets and sensitive API keys are handled exclusively through environment variables. The codebase uses os.getenv() to access runtime values such as MORNINGSTAR_API_KEY, raising explicit errors when required variables are missing. This pattern ensures that no credentials are hardcoded or stored in version-controlled configuration files.

Implementation Examples

The following patterns demonstrate how configurations are managed in AI Berkshire across different contexts:

# Loading data-driven configuration from JSON

import json
import pathlib

watchlist_path = pathlib.Path(__file__).parent.parent / "data" / "watchlist.json"
with watchlist_path.open() as f:
    watchlist = json.load(f)

# Command-line configuration using argparse

import argparse

parser = argparse.ArgumentParser(description="Sync Codex skills")
parser.add_argument("--check", action="store_true", help="Only verify, don’t write")
args = parser.parse_args()

if args.check:
    print("Running verification only...")

# Environment variable configuration for secrets

import os

api_key = os.getenv("MORNINGSTAR_API_KEY")
if not api_key:
    raise RuntimeError("Missing MORNINGSTAR_API_KEY environment variable")

Key Configuration Files

• .github/ISSUE_TEMPLATE/config.yml – Defines GitHub issue form layouts and required fields for repository contributors.

• scripts/sync-codex-skills.py – Demonstrates CLI-based configuration using argparse with flags like --check for verification-only execution.

• data/watchlist.json – Serves as a data configuration file containing watchlist entries consumed by financial analysis tools.

• tools/momentum_backtest.py – Contains hardcoded default parameters that can be overridden via command-line arguments at runtime.

Summary

• No centralized config file – AI Berkshire avoids monolithic configuration files in favor of distributed, purpose-specific settings.
• GitHub-native templates – Issue forms are configured via .github/ISSUE_TEMPLATE/config.yml for UI-level customization.
• CLI transparency – Scripts use argparse to expose toggles as explicit flags, making configuration visible and reproducible.
• Data as configuration – JSON and CSV files in data/ act as editable configuration sources for analysis parameters.
• Environment isolation – Secrets are strictly handled via os.getenv(), preventing credential leakage into version control.

Frequently Asked Questions

Does AI Berkshire use a centralized configuration file?

No. The repository does not ship with a .env, .ini, or YAML configuration file that governs the entire application. Instead, configurations are distributed across GitHub templates, CLI arguments, data files, and environment variables based on specific functional needs.

How are API keys and secrets handled?

API keys are accessed exclusively through environment variables using os.getenv(). The code expects secrets like MORNINGSTAR_API_KEY to be set in the runtime environment and raises explicit errors if they are missing, ensuring no sensitive data is committed to the repository.

Where are data settings like watchlists stored?

Watchlists and similar datasets are stored as JSON files in the data/ directory, such as data/watchlist.json. These files are loaded at runtime using json.load(), allowing users to update analytical parameters by editing the underlying data files rather than configuration scripts.

Can I override default parameters in the analysis tools?

Yes. Tools like tools/momentum_backtest.py define default parameters in the source code but expose them as command-line arguments. You can override these values when invoking the script, or modify the static data files in data/ to change the inputs the tools consume.

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