How do I install the Copaw Analysis skill?

Run npx skillmds@latest add suifei/copaw-analysis in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

Is Copaw Analysis safe to use?

This skill has not completed SkillMD's automated safety review yet. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Copaw Analysis?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Copaw Analysis free to use?

Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.

Who published Copaw Analysis?

suifei (@suifei) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Copaw Analysis by suifei — Agent Skill

Name: Copaw Analysis
Author: suifei

Copaw Analysis

Analyze CoPaw Python source modules to understand architecture, data flow, and dependencies for Go reimplementation. Use when the user asks to analyze, study, or understand a CoPaw module before implementing its Go equivalent.

suifei 2e3d896 2 files · 8.8 KB Updated Sep 17, 2026

File contents

CoPaw Source Analysis

When to Use

Before implementing a GopherPaw module, to understand the CoPaw original
When the user asks "how does CoPaw handle X?"
When mapping CoPaw functionality to Go architecture

Analysis Workflow

Analysis Progress:
- [ ] Step 1: Identify the target module
- [ ] Step 2: Read source files
- [ ] Step 3: Map architecture
- [ ] Step 4: Generate Go implementation recommendations

Step 1: Identify Target Module

Use the module map in reference.md to locate the relevant files. CoPaw has 8 major modules:

Agent - agents/react_agent.py (ReAct loop)
Runner - app/runner/ (runtime, session, chat management)
Channels - app/channels/ (messaging platforms)
Tools - agents/tools/ (built-in capabilities)
Memory - agents/memory/ (ReMe-based recall)
Providers - providers/ (LLM backends)
Config - config/ (Pydantic-based configuration)
CLI - cli/ (command-line interface)

Step 2: Read Source Files

For each target module, read:

The main implementation file(s)
The __init__.py for public API surface
Related test files in tests/
Any referenced utility modules

Step 3: Map Architecture

Produce a structured analysis:

Module Summary

## [Module Name]

### Purpose
[One paragraph: what problem does this solve?]

### Key Classes/Functions
- `ClassName` - [responsibility]
- `function_name()` - [what it does]

### Data Flow
[Mermaid sequence diagram or flowchart]

### Dependencies
- Internal: [other CoPaw modules used]
- External: [third-party libraries]

### State Management
- [What state is stored, where, and how]

### Error Handling
- [How errors are propagated and recovered]

Step 4: Go Implementation Recommendations

Based on the analysis, recommend:

Go package placement: Which internal/ package should hold this?
Interface design: What Go interfaces should be defined?
Key differences: What should NOT be directly translated?
Risks: What parts are complex or error-prone?
Priority: What to implement first for a working MVP?

Module Map Reference

For detailed file paths and module relationships, see reference.md.

---name: copaw-analysisdescription: Analyze CoPaw Python source modules to understand architecture, data flow, and dependencies for Go reimplementation. Use when the user asks to analyze, study, or understand a CoPaw module before implementing its Go equivalent.---# CoPaw Source Analysis## When to Use- Before implementing a GopherPaw module, to understand the CoPaw original- When the user asks "how does CoPaw handle X?"- When mapping CoPaw functionality to Go architecture## Analysis Workflow```Analysis Progress:- [ ] Step 1: Identify the target module- [ ] Step 2: Read source files- [ ] Step 3: Map architecture- [ ] Step 4: Generate Go implementation recommendations```### Step 1: Identify Target ModuleUse the module map in [reference.md](reference.md) to locate the relevant files. CoPaw has 8 major modules:1. **Agent** - `agents/react_agent.py` (ReAct loop)2. **Runner** - `app/runner/` (runtime, session, chat management)3. **Channels** - `app/channels/` (messaging platforms)4. **Tools** - `agents/tools/` (built-in capabilities)5. **Memory** - `agents/memory/` (ReMe-based recall)6. **Providers** - `providers/` (LLM backends)7. **Config** - `config/` (Pydantic-based configuration)8. **CLI** - `cli/` (command-line interface)### Step 2: Read Source FilesFor each target module, read:1. The main implementation file(s)2. The `__init__.py` for public API surface3. Related test files in `tests/`4. Any referenced utility modules### Step 3: Map ArchitectureProduce a structured analysis:**Module Summary**```markdown## [Module Name]### Purpose[One paragraph: what problem does this solve?]### Key Classes/Functions- `ClassName` - [responsibility]- `function_name()` - [what it does]### Data Flow[Mermaid sequence diagram or flowchart]### Dependencies- Internal: [other CoPaw modules used]- External: [third-party libraries]### State Management- [What state is stored, where, and how]### Error Handling- [How errors are propagated and recovered]```### Step 4: Go Implementation RecommendationsBased on the analysis, recommend:1. **Go package placement**: Which `internal/` package should hold this?2. **Interface design**: What Go interfaces should be defined?3. **Key differences**: What should NOT be directly translated?4. **Risks**: What parts are complex or error-prone?5. **Priority**: What to implement first for a working MVP?## Module Map ReferenceFor detailed file paths and module relationships, see [reference.md](reference.md).

Frequently asked questions