ralph-wiggum

🥈Silver

Ralph Wiggum enables autonomous AI coding with spec-driven development. Operations teams benefit by automating code generation and maintenance. It connects to shell-based workflows and is supported by Claude agents.

21580Updated Today

Intermediate30min to implementautomation

Saves ~120 min per use

Quick InstallView Source

git clone https://github.com/fstandhartinger/ralph-wiggum.git

Works with:

Claude

Overview

About This Skill

How to Use

[{"step":"Prepare your specification document","action":"Write a detailed spec including: project name, language, architecture requirements, key features, and deployment targets. Save as a .txt or .md file.","tip":"Use bullet points for requirements. Include constraints like 'Must use PostgreSQL' or 'No external dependencies'."},{"step":"Run the Ralph Wiggum command in your terminal","action":"Execute: `claude --skill ralph-wiggum --spec ./spec.txt --output ./project` in your project directory. Replace './spec.txt' with your spec file path.","tip":"Ensure you have Docker installed and running. The skill will create a new directory with the full project structure."},{"step":"Review and customize the generated code","action":"Open the generated project in your IDE. Check the README.md for setup instructions, then modify any files as needed for your specific use case.","tip":"Focus on business logic first. The generated tests and CI/CD pipelines are production-ready but may need environment-specific tweaks."},{"step":"Deploy and verify","action":"Run `docker-compose up --build` to start all services. Test the endpoints using curl or Postman, then check the logs with `docker-compose logs -f`.","tip":"Use `docker stats` to monitor resource usage. The health check endpoint (/health) should return 200 OK."},{"step":"Iterate with additional specs","action":"For new features, update your spec file and rerun the command. The skill will generate diffs for changed files, preserving your modifications.","tip":"Keep specs version-controlled. Each run creates a timestamped backup of your project."}]

Setup & Installation

Quick Install

No install command available. Check the GitHub repository for manual installation instructions.

Alternative Install (Git Clone)

git clone https://github.com/fstandhartinger/ralph-wiggum

Requirements

Claude Code or compatible AI agent
Works with: Claude

Quick Start Guide

Install the Skill

Copy the install command above and run it in your terminal.

Open Your AI Agent

Launch Claude Code, Cursor, or your preferred AI coding agent.

Try It Out

Use the prompt template or examples below to test the skill.

Customize

Adapt the skill to your specific use case and workflow.

Usage Examples

Prompt Template

Act as Ralph Wiggum and autonomously generate a complete, production-ready [LANGUAGE] codebase for [PROJECT_NAME] based on the following specification: [SPECIFICATION]. The code must include: 1) A modular architecture with clear separation of concerns, 2) Comprehensive error handling and logging, 3) Unit tests with 90%+ coverage, 4) Documentation in Markdown format, and 5) A CI/CD pipeline configuration (GitHub Actions/GitLab CI). Deploy the code to a local Docker container named [CONTAINER_NAME] and verify all services are running. Provide the complete directory structure and all files in a single ZIP archive.

Example Output

```
Project: 'TinyBlog' - A minimalist blogging platform
Language: Python 3.11
Architecture: MVC with FastAPI backend, Jinja2 templates, and SQLite database

Directory Structure:
TinyBlog/
├── app/
│   ├── __init__.py
│   ├── main.py (FastAPI app with 10 endpoints)
│   ├── models.py (SQLAlchemy ORM with 4 tables)
│   ├── schemas.py (Pydantic models for 8 request/response types)
│   ├── services/
│   │   ├── __init__.py
│   │   ├── post_service.py (CRUD operations with 12 methods)
│   │   └── user_service.py (Auth with JWT tokens)
│   └── utils/
│       ├── __init__.py
│       ├── logging.py (Structured logging with 5 log levels)
│       └── exceptions.py (Custom exceptions with 8 types)
├── tests/
│   ├── __init__.py
│   ├── test_models.py (15 test cases, 95% coverage)
│   ├── test_routes.py (22 endpoint tests, 98% coverage)
│   └── conftest.py (Fixtures for 3 test scenarios)
├── templates/
│   ├── base.html (Layout with Bootstrap 5)
│   ├── index.html (Homepage with 3 dynamic sections)
│   └── post.html (Single post view with comments)
├── static/
│   ├── css/
│   │   └── style.css (240 lines, mobile-first)
│   └── js/
│       └── main.js (Vanilla JS with 8 functions)
├── Dockerfile (Multi-stage build, 120MB final image)
├── docker-compose.yml (PostgreSQL + Redis + App services)
├── requirements.txt (Production + Development dependencies)
├── .github/workflows/
│   └── ci-cd.yml (Tests, linting, build, deploy to Render)
├── README.md (Installation, usage, API docs)
└── .env.example (Environment variables template)

Verification:
✅ All 37 unit tests pass (98.2% coverage)
✅ FastAPI app starts on http://localhost:8000
✅ PostgreSQL connected at port 5432
✅ Redis cache running at port 6379
✅ Docker container 'tinyblog-app' running (port 8000:8000)
✅ Health check endpoint /health returns {"status": "ok"}

Next Steps:
1. Run 'docker exec -it tinyblog-app bash' to access the container
2. Use 'alembic' for database migrations
3. Configure SMTP in .env for email notifications
4. Deploy to Render using the GitHub Actions workflow
```