Generic Agentic AI CLI Framework Setup

Description

This skill configures Claude Code to work with a generic, pluggable agentic AI CLI framework. The framework provides a standalone, reusable CLI interface for creating, testing, and deploying agentic systems with any LLM provider or framework. It emphasizes agent-agnostic design, portability, and microservice-ready architecture.

Project Context

What This Framework Is

What This Framework Is NOT

Architecture Principles

Instructions

1. Development Environment Setup

**CRITICAL**: This project uses `uv` for dependency management. Always use `uv run` to execute commands.

When working in this repository:

1. **Run tests**: `uv run pytest`

2. **Execute Python scripts**: `uv run python script.py`

3. **Run linting**: `uv run ruff check src tests`

4. **Format code**: `uv run ruff format src tests`

5. **Any other command**: Prefix with `uv run`

2. File Operation Guidelines

**CRITICAL - Only Create or Modify Files When Explicitly Requested**

3. Task Management Approach

When handling multi-step tasks:

1. Use `TodoWrite` to plan and track tasks with 3+ steps

2. Break complex features into smaller, manageable steps

3. Mark todos as `in_progress` when starting work

4. Mark todos as `completed` immediately when done (don't batch completions)

4. Architecture & Code Quality

When implementing features:

1. **Keep agents self-contained and microservice-ready**

- Agents must be extractable and usable without the CLI

- Design for portability (web, notebooks, batch processing)

2. **Use dependency injection**

- Pass all dependencies via constructors

- Avoid global state

- Maintain clear interfaces and contracts

3. **Maintain CLI-Agent boundary**

- Agents cannot import from CLI package

- CLI layer is disposable - agents work independently

4. **Keep framework generic**

- No domain-specific code in core framework

- Design for extensibility and pluggability

5. Development Workflow

For each task:

1. **Understand Requirements**: Ask clarifying questions if needed using `AskUserQuestion`

2. **Plan**: Use `TodoWrite` for multi-step tasks

3. **Implement**: Write code following architecture principles

4. **Verify**: Run tests with `uv run pytest`

5. **Complete**: Mark todos as done immediately after verification

6. Testing & Verification

Before marking any task complete:

7. Key Constraints

Examples

Example 1: Running Tests

```bash

uv run pytest

```

Example 2: Adding a New Agent Implementation

When asked to add a new agent:

1. Create agent class implementing the agent interface

2. Use dependency injection for LLM provider

3. Keep agent stateless - accept conversation context as parameters

4. Ensure agent has no CLI dependencies

5. Test with `uv run pytest`

Example 3: Modifying Existing Code

When asked to modify a feature:

1. Read existing files first

2. Use `Edit` tool to modify (don't create new files)

3. Maintain architecture principles

4. Run tests to verify changes

Important Notes