Interactive skill set framework for Claude Code, OpenAI Codex, Grok Build, OpenCode, and Kilo Code

Ashley provides 14 composable, production-ready skills that encode software engineering best practices as structured prompts for your coding agent. Skills are assembled from reusable components and inlined resources, then installed for Claude Code (/a-feat), OpenAI Codex ($a-feat), Grok Build, OpenCode, or Kilo Code — the same SKILL.md serves all five.

• 14 specialized skills — feat, refactor, debug, optimize, commit, scaffold, and more
• Five agent backends — Claude Code, Codex, Grok Build, OpenCode, and Kilo Code, switchable globally or per run
• Skill pipelines — chain skills with + syntax (feat+commit+changelog) or named pipelines
• Lifecycle hooks — run shell commands before/after any skill execution
• Project detection — auto-detects tech stack for context-aware prompts
• Interactive TUI — hub with skill browser, session manager, history, analytics, and themeable appearance
• tmux-backed sessions — every run is crash-resilient; detach to background with --detached
• Invocation history — every run logged to SQLite for search and review

Ashley ships as one Go executable for macOS and Linux on arm64 and amd64. Skills, components, and resources are embedded: users need no Go, Python, uv, or source checkout. Coding-agent CLIs and tmux remain separate dependencies. The project stays open source; development and release tooling use Go.

Existing YAML settings, JSON preferences, SQLite history, and tmux sessions remain compatible. See Migrating from Python for the launcher replacement and custom-skill import procedure. Development and release commands are documented in binary release development.

curl -fsSL https://raw.githubusercontent.com/LBYPatrick/ashley/main/scripts/remote-install.sh | bash

Downloads and verifies the matching release binary into ~/.local/bin/ash, then installs skills and the selected agent. No checkout, Python, uv, or Go toolchain is installed. Native release assets are available starting with v0.4.0.

The optional skills.sh CLI is not installed by default. To install it and any missing runtime dependencies automatically:

curl -fsSL https://raw.githubusercontent.com/LBYPatrick/ashley/main/scripts/remote-install.sh | ASHLEY_INSTALL_SKILLS=1 bash

This opt-in also applies to scripts/install.sh, including binary-only installs.

When Skills is already available or you opted into installing it, agent setup also asks whether to install all of Emil Kowalski's skills plus find-skills from vercel-labs/skills. Accepting installs the bundle globally for the same selected Ashley agents, without further skill or agent pickers. Declining leaves the community bundle uninstalled. This question is also offered by ash install; binary-only installation does not select agents or offer bundles. Without a terminal, the optional bundle is skipped unless configured below.

The installer asks which coding agent to set up. Skip the question with a flag:

curl -fsSL .../remote-install.sh | bash -s -- --codex   # or --claude, --grok, --opencode, --kilo, --all

The normal remote installer automatically migrates Python installations; no separate migration command is needed:

curl -fsSL https://raw.githubusercontent.com/LBYPatrick/ashley/main/scripts/remote-install.sh \
  | bash -s -- --version 1.1.0

It finds the old checkout through launcher symlinks or ~/.ashley/repo (ASHLEY_DIR is also supported), verifies the native release, and imports skill definitions, components, resources, and generated packages into ~/.ashley. Existing user files win over imported files. Imported files remain local overrides of the embedded defaults, preserving customizations.

Before replacing the launcher, migration backs it up and moves existing agent skill links off the checkout using the native executable. This preservation step runs without Python, uv, dependency installation, or prompts. The normal remote installer then performs the requested agent setup. Use --skills-only --codex to skip agent CLI installation, or --binary-only to skip subsequent setup while still preserving an existing skill installation.

The installer also backs up and redirects recognized Python or Go wrappers that take precedence on PATH. An unwritable shadowing launcher produces an error before replacement and instructions to put the install directory first on PATH. Unrelated executables (including a system shell named ash) are never redirected. --install-dir DIR selects a custom destination.

Backups live under ~/.ashley/migrations/python-to-go-*. Settings, SQLite history, session logs, the old checkout/virtualenv, and shared Python/uv installations are retained. If verification or migration skill setup fails, the launcher stays unchanged; any imported files and backups remain available for inspection. Symlinked skill data is rejected rather than copied through. Subsequent native installs do not repeat migration.

For offline or explicit-source recovery, the standalone compatibility helper is still available:

bash scripts/migrate-python.sh --binary /path/to/ash --source ~/code/ashley

Start a new shell (or run hash -r), then check ash --version, ash history show, and ash list. After verifying your custom skills and old history, you can remove the old checkout and its .venv; the Go installation no longer needs them. Do not run the old checkout's make uninstall, which would remove the new links. To restore the previous launcher, retain its old checkout, remove the new launcher, and copy the saved ash back with cp -Pp BACKUP/ash ~/.local/bin/ash.

git clone https://github.com/LBYPatrick/ashley.git
cd ashley
make build           # Standalone executable: build/ash-go
./build/ash-go --version
make install         # Optional: install the CLI and skills

make build GOOS=linux GOARCH=arm64 BUILD_OUTPUT=build/ash-linux-arm64
make build GOOS=windows GOARCH=amd64  # build/ash-go.exe

Copy ashley-automated.example.json to a local ashley-automated.json, then edit your choices:

{
  "agents": ["claude", "codex"],
  "skills_only": false,
  "install_skills": true,
  "community_skills": true
}

curl -fsSL https://raw.githubusercontent.com/LBYPatrick/ashley/main/scripts/remote-install.sh | \
  ASHLEY_AUTOMATED_CONFIG="$PWD/ashley-automated.json" ASHLEY_AUTOMATED=1 bash

Both variables are required to activate the profile. The path refers to an existing local file (a mounted file works too); the filename itself is unrestricted. Supplying a path without enabling ASHLEY_AUTOMATED leaves normal interactive setup active. The same variables work with ash install and scripts/install.sh.

The profile overrides command-line agent/skills-only selections and ASHLEY_INSTALL_SKILLS. community_skills: true can reuse an existing Skills installation with install_skills: false; missing dependencies then cause an error. Unknown fields, duplicate/unknown agents, invalid JSON, and missing configuration fail without prompting. The downloaded binary validates the profile before replacing the existing launcher. Automated mode rejects --binary-only because the profile specifies agent setup.

Silent mode means no interactive input or selection prompts: progress and errors remain visible, and the installation log includes community setup output. External commands use noninteractive settings, and bundle installation passes explicit agent and skill selections plus --yes. Failures return a nonzero status; no interactive fallback is attempted. Agent account authentication remains a separate step.

ash uninstall
rm ~/.local/bin/ash
# Your settings, custom skills, logs, and history are retained.

# Launch interactive TUI (default)
ash

# Run a skill directly
ash run feat "Add a login page"
ash run debug "Fix the 500 error on /api/users"

# Autonomous mode (no prompts)
ash run -afk feat "Add dark mode toggle"

# Pick the agent just for this run
ash run -o feat "Add dark mode toggle"     # OpenAI Codex
ash run -c feat "Add dark mode toggle"     # Claude Code

# Run a pipeline (chain skills)
ash pipe feat+commit+changelog "Add OAuth support"

# Detached session (background)
ash run --detached feat "Add OAuth support"

# Generate a copy-pasteable prompt
ash prompt feat "Add OAuth support"

# List available skills
ash list

On Linux and macOS, ash skills forwards all arguments, input, output, and exit status to the native Skills CLI:

ash skills --help
ash skills find
ash skills add vercel-labs/agent-skills
ash skills list
ash skills remove
ash skills update

Ashley detects pnpm/npm, Node.js, and the skills executable. If dependencies are missing, it displays an installation plan and asks for confirmation. Declining or reaching end-of-input cancels setup. For unattended use:

ASHLEY_INSTALL_SKILLS=1 ash skills --version

Setup uses an existing pnpm or npm installation; if neither exists, it installs standalone pnpm. Missing or unsupported Node.js is installed as LTS through pnpm (bootstrapping pnpm if needed). Skills is installed with pnpm add --global skills or npm install --global --prefix ~/.ashley/tools skills. No sudo is needed. Ashley refreshes PATH and verifies dependencies in the same invocation, including both older pnpm layouts and pnpm 12's PNPM_HOME/bin, so no terminal restart is needed. PNPM_HOME is respected; otherwise it uses ~/Library/pnpm on macOS or ${XDG_DATA_HOME:-~/.local/share}/pnpm on Linux. The pnpm installer may also update your shell configuration.

Every argument after ash skills, including --help and --yes, belongs to the Skills CLI; use the environment variable above to approve Ashley's dependency setup. This integration requires Bash and curl for bootstrap; use WSL on Windows. Skills installed through this command are managed by the upstream CLI. Ashley's built-in catalog remains available through ash list and ash install.

Chain multiple skills into sequential execution. The first skill receives your question; subsequent skills run with their default trigger. Execution stops on first failure.

# Inline pipeline with '+' syntax
ash pipe feat+commit "Add login page"
ash pipe refactor+commit+changelog "Clean up auth"

# Named pipelines in ~/.ashley/config.yaml
pipelines:
  ship:
    - feat
    - commit
    - changelog

Run shell commands before or after skill execution. Hooks receive context via environment variables ($ASHLEY_SKILL, $ASHLEY_QUESTION, $ASHLEY_EXIT_CODE).

# ~/.ashley/config.yaml
hooks:
  global:
    before_run: "echo 'Starting: $ASHLEY_SKILL'"
    after_run: "echo 'Done: $ASHLEY_SKILL (exit $ASHLEY_EXIT_CODE)'"
  skills:
    feat:
      after_run: "make format"
    commit:
      before_run: "make test"

Hook points: before_run, after_run, on_error. A non-zero before_run aborts the skill run.

Run ash to launch the hub:

Open Skills.sh from the hub or the Ctrl+P command palette. Select an action with arrows and Enter; Find and Add accept a search term or repository/URL. Add, List, and Remove operate on globally installed skills. Native Skills prompts handle skill/agent selection and missing-dependency consent. Command output remains visible until you press Enter to return to Ashley. Community bundle setup reuses Ashley’s agent selection and asks before adding Emil’s skills and find-skills. Opening the page does not install anything.

Sync detects supported agent executables on PATH and in native install locations, then generates skills into ~/.ashley/generated before installing links for every detected agent. Every activation runs the complete sync again. The full per-file and per-agent log stays visible; use PgUp/PgDn or Home/End to scroll, and R to rerun. Press I to set up the agent selected in Settings. Standalone ash generate and ash install commands remain available for scripts and explicit CLI use.

On first launch the TUI runs a quick setup wizard to pick your appearance. The whole TUI is fully keyboard-operable (Tab, arrows, Enter, Esc) — no mouse required, so it works over SSH/mosh.

The creator guides you through basics, component/resource selection, workflow, and preview. Use Tab to change fields, Ctrl+N to advance, Esc to go back, and Ctrl+S to save. In the workflow step, Ctrl+A adds a step, Ctrl+D removes it, and Ctrl+Left/Right switches steps. Ctrl+E opens the advanced JSON editor. New definitions live in ~/.ashley/skills (or --root/skills for a checkout).

Inside Vibe you can pick a run mode before launching — Normal (standard permission prompts), DSP (skip all permission checks), AUTO (auto-accept edits), or AFK (fully autonomous, implies DSP). Press m to cycle modes or click a chip; these map to the same flags as ash run.

Ashley supports Claude Code, Codex, Grok Build, OpenCode, and Kilo Code. All read the same generated SKILL.md packages. Claude and Grok use slash commands, Codex uses $ mentions, and Ashley asks OpenCode and Kilo to load the named skill. Kilo installation requires Node.js/npm; its bootstrap uses npm install -g @kilocode/cli.

The shipped executable embeds all built-in skill definitions, components, and resources. ash install --all --skills-only assembles them into ~/.ashley/generated and links them into the agents’ user directories, without a source checkout, network access, or Go/Python tooling. Agent CLI setup may require its vendor’s network installer.

Installing from --root imports complete custom packages from generated/, including supporting files and executable scripts, into ~/.ashley/generated. They remain usable without the checkout. Every install regenerates prompts and replaces local edits and conflicting paths for the skills being installed. Edit source definitions under ~/.ashley/skills and ~/.ashley/components to maintain custom behavior; generated SKILL.md files are disposable outputs.

CLI output groups setup and sync into readable sections. Each installation saves a complete log under ~/.ashley/logs/; use ash install --verbose to also stream per-file details. TUI Sync continues to display its full log. Human-facing tables adapt to terminal width, and redirected output has no ANSI styling. NO_COLOR or ASHLEY_NO_COLOR disables terminal colors.

ash install --codex        # install skills for Codex
ash install --both         # Claude Code + Codex (backward-compatible)
ash install --grok --opencode --kilo
ash install --all          # all five agents

ash agent                  # show the current default, its version and install source
ash agent codex            # change the default

ash run -o feat "..."      # override for one run (Codex)
ash run -c feat "..."      # override for one run (Claude Code)
ash run --grok feat "..."
ash run --opencode feat "..."
ash pipe --kilo feat+commit "..."  # same flags work for pipelines

Ashley detects how each agent CLI was installed and upgrades it the same way:

ash upgrade --check --all  # report version + install source, change nothing
ash upgrade                # upgrade the default agent
ash upgrade codex          # upgrade a specific agent
ash upgrade --all          # upgrade all five

Homebrew ownership is detected from Cellar/Caskroom paths. Files elsewhere under the brew prefix, including npm's codex.js, are not treated as formulae. Native installers are used for Claude, Codex, Grok, and OpenCode; Kilo uses npm.

ash update runs this upgrade as its last step, covering whichever agents have Ashley skills linked. Skip it with SKIP_TOOL:

ash update                 # update Ashley, then upgrade the agent CLIs
SKIP_TOOL=1 ash update     # update Ashley only (also: true / yes)
SKIP_TOOL=1 make update

ash update refreshes Ashley skills without offering the optional community bundle or replaying automated installation profiles. Use ash install or the TUI Skills.sh page to add that bundle explicitly.

The default is saved to ~/.ashley/prefs.json and can also be changed from the TUI Settings screen. Run modes map to the available backend controls:

Grok maps -dsp to --always-approve and --auto to --permission-mode auto. OpenCode and Kilo map both modes to --auto; explicit deny rules still apply. For every backend, -afk adds autonomous instructions to the DSP mode. See the Grok permission guide, OpenCode CLI reference, and Kilo CLI reference.

Ashley's look is configurable from the Settings screen in the TUI (or the first-run wizard). Choose:

• Mode — Clear (default), Dark, or Light
• Colour — a primary colour (Blue, Green, Purple, Orange, Rose, Cyan) or a dual-tone preset (Ocean, Sunset, Grape, Forest)

Changes preview instantly and are saved to ~/.ashley/theme.json, then auto-loaded on every launch. The default is Blue + dark.

Every run launches the coding agent inside a tmux session for crash resilience. Without --detached, Ashley attaches to it immediately (exiting cleans it up); with --detached, it runs in the background for you to manage later.

Ashley enables mouse scrolling for its sessions: wheel up opens tmux scrollback instead of sending arrow keys to the agent. Press q (or Esc in vi copy mode) to return to typing. Existing sessions receive this fix when reattached with ash attach. Other tmux sessions keep their settings.

ash run feat "Add OAuth support"            # runs in tmux, attaches immediately
ash run --detached feat "Add OAuth support" # background session
ash sessions               # TUI session manager
ash attach <session-id>    # Attach to interact
ash logs -f <session-id>   # Follow log in real time
ash kill <session-id>      # Kill a session
ash kill all               # Kill all sessions

Detaching from a foreground run (Ctrl-b d) leaves it running in the background, just like --detached.

Session manager keys:

Every ash run is logged to SQLite.

ash history show                 # Recent invocations
ash history show --skill feat    # Filter by skill
ash history browse               # Interactive browser (TUI)
ash history stats                # Usage by skill and by agent
ash history stats --agent codex  # Restrict analytics to one agent
ash history prune 30             # Delete entries older than 30 days
ash history info                 # DB location and stats

Each invocation records which coding agent ran it. Existing databases are migrated automatically on the next run — invocations logged before multi-agent support are counted as Claude Code.

ash                              Launch hub TUI
ash vibe                         Skill browser TUI
ash run <skill> [question]       Run a skill
ash run --detached <skill> [q]   Run in background
ash run raw [question]           Run the coding agent without a skill
ash pipe <a+b+c> [question]      Run a skill pipeline
ash generate                     Assemble skill files from JSONC
ash list                         List available skills
ash skills [commands/options]    Forward native skills.sh commands
ash prompt <skill> [question]    Print prompt to stdout
ash sessions                     Manage detached sessions (TUI)
ash attach <id>                  Attach to a session
ash logs [-f] <id>               View/follow session logs
ash kill <id|all>                Kill sessions
ash history show                 Show invocation history
ash history browse               Interactive history browser
ash history stats [--agent X]    Usage analytics by skill and agent
ash history prune <days>         Delete old entries
ash history clear                Delete all history
ash history info                 Database stats
ash agent [name]                 Show or set the default coding agent
ash upgrade [names] [--all]      Detect + upgrade the agent CLIs (--check to report only)
ash install [--claude|--codex|--grok|--opencode|--kilo|--all]   Generate + install skills
ash uninstall                    Remove skills
ash update [--version VERSION]  Install verified binary release + refresh skills
ash --version                    Print version

skills/             JSONC skill definitions
components/         Reusable markdown instruction blocks
res/                Code templates and reference docs
cmd/ash/            Native executable entry point
internal/           Go CLI, TUI, generation, sessions, history, and updates
tests/integration/  Go binary, terminal, package, installer, and migration tests
tests/fixtures/     Reviewed regression reference outputs
scripts/release/    Packaging, version validation, and publishing
scripts/dev/        Local development helpers
docs/migration/     Migration acceptance and release parity checklist

assets.go stays at the module root so Go can embed the shared skill sources directly, without a generated copy. Build outputs (build/, dist/, and generated/) and test caches are ignored; make clean removes them.

For new projects without an explicit stack, coding guidance selects Rust for edge workloads requiring extreme performance, Python for ML/data analytics when lower runtime performance is acceptable, and Go otherwise. Web frontends default to Vue + TypeScript + Vite. Explicit choices and existing stacks take precedence; both Vue and React component references remain bundled.

Skills are JSONC files referencing reusable components and code resources. The generator assembles them into self-contained markdown prompts with all resources inlined. Project detection provides tech stack context to Jinja2 templates for conditional content.

git clone https://github.com/LBYPatrick/ashley.git
cd ashley
make build          # Build the standalone executable
make generate       # Regenerate skills
make test           # Run tests
make format         # Format Go and check shell syntax

MIT

Clear mode uses your terminal’s background and foreground, so configured transparency or blur remains visible. It does not enable terminal transparency itself. Existing saved Dark or Light preferences are preserved; choose Clear in Settings to switch.