https://github.com/athrael-soju/framework-generator
Create structured, repeatable frameworks from any workflow through guided stages. Human-in-the-loop design with Claude.
https://github.com/athrael-soju/framework-generator
anthropic claude claude-code claude-plugins claude-skills framework-generator workflow-automation
Last synced: about 8 hours ago
JSON representation
Create structured, repeatable frameworks from any workflow through guided stages. Human-in-the-loop design with Claude.
- Host: GitHub
- URL: https://github.com/athrael-soju/framework-generator
- Owner: athrael-soju
- License: mit
- Created: 2026-01-04T17:51:02.000Z (6 months ago)
- Default Branch: main
- Last Pushed: 2026-02-06T21:57:42.000Z (5 months ago)
- Last Synced: 2026-02-07T08:51:16.356Z (5 months ago)
- Topics: anthropic, claude, claude-code, claude-plugins, claude-skills, framework-generator, workflow-automation
- Homepage:
- Size: 505 KB
- Stars: 1
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Framework Generator
A tool for creating structured, repeatable frameworks with executable skills through staged refinement. Works with Claude Code.
## Installation
```bash
git clone https://github.com/athrael-soju/Framework-Generator.git
cd framework-generator
claude
```
Claude Code will automatically read the project's `CLAUDE.md` for context and instructions.
## Usage
Once in a Claude Code session, ask Claude to execute stages:
| Request | Description |
|---------|-------------|
| "Run Frame stage for {name}" | Define framework purpose and boundaries |
| "Run Organize stage for {name}" | Map stages and flow |
| "Run Refine stage for {name}" | Specify each stage in detail |
| "Run Generate stage for {name}" | Produce framework artifacts |
| "Run Evaluate stage for {name}" | Validate and iterate |
See the `commands/` directory for detailed stage instructions.
## Workflow
```
┌─────────┐ ┌──────────┐ ┌────────┐ ┌──────────┐ ┌──────────┐
│ Frame │───▶│ Organize │───▶│ Refine │───▶│ Generate │───▶│ Evaluate │
└─────────┘ └──────────┘ └────────┘ └──────────┘ └──────────┘
▲ │
└────────────────── feedback loops ──────────────────────────┘
```
## Quick Start
### 1. Start a new framework
```
Run Frame stage for my-workflow
```
You'll be asked about:
- What workflow needs systematizing
- Domain, constraints, intended users
- Scope boundaries
**Output:** Framework charter in `output/{date}/my-workflow/1-frame/charter.md`
### 2. Organize the stages
```
Run Organize stage for my-workflow
```
Define:
- Major phases of work (3-7 stages)
- How stages connect
- Feedback loops and terminal states
**Output:** Stage map in `output/{date}/my-workflow/2-organize/stage-map.md`
### 3. Refine each stage
```
Run Refine stage for my-workflow
```
For each stage, specify:
- Activities with inputs/outputs
- Context tables (criteria, categories)
- Output templates
- Quality criteria
**Output:** Stage specs in `output/{date}/my-workflow/3-refine/{stage}-spec.md`
### 4. Generate artifacts
```
Run Generate stage for my-workflow
```
Produces:
- Stage skill files
- README and CLAUDE.md
- Complete framework structure
**Output:** Complete framework in `output/{date}/my-workflow/4-generate/my-workflow/`
### 5. Evaluate and iterate
```
Run Evaluate stage for my-workflow
```
Validates:
- Convention compliance
- Completeness
- Consistency
- Dry run of first stage
**Output:** Validation report in `output/{date}/my-workflow/5-evaluate/validation.md`
## Output Structure
```
output/{date}/{framework-name}/
├── run.md # Progress tracking
├── 1-frame/
│ └── charter.md # Framework charter
├── 2-organize/
│ └── stage-map.md # Stage map with flow diagram
├── 3-refine/
│ └── {stage}-spec.md # Stage specifications
├── 4-generate/
│ └── {framework-name}/
│ ├── .claude/
│ │ └── settings.local.json # Claude Code permissions
│ ├── .claude-plugin/
│ │ └── plugin.json # Plugin manifest
│ ├── commands/
│ │ └── {stage}.md # Stage command files
│ ├── README.md # Framework overview
│ └── CLAUDE.md # AI instructions
└── 5-evaluate/
└── validation.md # Validation report
```
## Principles
### Human-in-the-Loop
Every stage requires approval before proceeding. This ensures:
- User maintains control over design decisions
- Quality gates prevent cascading errors
- Feedback can be incorporated early
### Quality Criteria
Each stage has explicit checklists:
- Verifiable criteria (not vague prose)
- Coverage of completeness and correctness
- Clear pass/fail determination
### Feedback Loops
Built-in iteration paths:
- Evaluate → Refine (specification gaps)
- Evaluate → Organize (structural issues)
- Evaluate → Frame (scope problems)
### Self-Contained Output
Generated frameworks include everything needed to run independently:
- No external document references
- Embedded output templates
- Complete process instructions
- `.claude/settings.local.json` for permission configuration
### Permissions
Generated frameworks include `.claude/settings.local.json` with `bypassPermissions` enabled. This allows Claude Code to execute commands without prompting for approval at each step.
**Risks:**
- Claude can execute shell commands, read/write files, and make network requests without confirmation
- Malformed or misunderstood instructions could lead to unintended file modifications
- Review generated framework commands before use
**Alternatives:**
- Delete `.claude/settings.local.json` to restore default permission prompts
- Edit to use `"defaultMode": "default"` for selective approval
## Framework Types
| Type | Pattern | Example |
|------|---------|---------|
| Foundation | Single assessment, run once | Initial analysis |
| Pipeline | Sequential stages, ongoing | Feature development |
| Cyclical | Repeating on cadence | Weekly reviews |
| Hub | Central stage, others connect | Decision framework |
## License
MIT