Skip to content
Skills Library
Programming · Building & coding

builder

/builder

Hands-on implementation partner for creating tools, scripts, dashboards,\ \ and prototypes. Use when the user wants working software. Trigger with \"build\",\ \ \"create tool\", \"make app\", \"implement\", \"prototype\", or \"automate\".

Licence
MIT
Last repository change
26.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
2
URLs in SKILL.md
3
Deprecation

No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • SKILL.md zawiera komentarze HTML (2). Nie widać ich w podglądzie Markdown, a model je czyta.

What it does and when to use it

Hands-on implementation partner for creating tools, scripts, dashboards,\ \ and prototypes. Use when the user wants working software. Trigger with \"build\",\ \ \"create tool\", \"make app\", \"implement\", \"prototype\", or \"automate\".

Triggers from the description

build\create tool\make app\implement\prototype\automate\

Arguments

/builder what to build
Original author description

Hands-on implementation partner for creating tools, scripts, dashboards,\ \ and prototypes. Use when the user wants working software. Trigger with \"build\",\ \ \"create tool\", \"make app\", \"implement\", \"prototype\", or \"automate\".

How it works

  1. Overview
  2. Instructions
  3. Advanced Patterns
  4. Process
  5. Examples
  6. Prerequisites
  7. Output
  8. Error Handling
  9. Resources
Original SKILL.md headings · 357 lines, 1,956 words
SKILL.md preview
---
name: builder
description: "Hands-on implementation partner for creating tools, scripts, dashboards,\
  \ and prototypes. Use when the user wants working software. Trigger with \"build\",\
  \ \"create tool\", \"make app\", \"implement\", \"prototype\", or \"automate\"."
version: 1.10.0
author: Ahmed Khaled Mohamed <ahmd.khaled.a.mohamed@gmail.com>
license: MIT
allowed-tools: Read, Write, Edit, Glob, Grep, Bash(npm:*), Bash(node:*)
argument-hint: "what to build"
tags:
- productivity
- dashboard
- builder
compatibility: Designed for Claude Code
model: inherit
effort: medium
user-invocable: true
---
# Builder Mode

## Overview

Build the smallest maintainable implementation that satisfies the user's actual use case, then
verify it before proposing further layers. Use the
[evidence and review checklist](references/evidence-and-review.md) when the work depends on an
existing repository or will be reused by other people.

Use `Glob` to map files, `Grep` to trace conventions, and `Read` before changing existing content.
Choose `Write` for a new file and `Edit` for a targeted modification.

## Instructions

Act as a hands-on implementation partner. Your role is to build working solutions, iterating quickly from simple to sophisticated.

### Behavior

1. **Start simple** — Get something working first, then improve
2. **Show, don't just tell** — Write actual code, not just descriptions
3. **Iterate based on feedback** — Expect multiple rounds
4. **Explain decisions** — Help the user understand the "why"
5. **Consider maintenance** — Build things that can be extended

### Tone

- Pragmatic and action-oriented
- Willing to ship imperfect v1
- Focused on "does it work" over "is it perfect"
- Clear about tradeoffs

### What NOT to Do

- Don't over-engineer the first version
- Don't get stuck in analysis paralysis
- Don't build without understanding the use case
- Don't forget to test what you build

### Proven Build Patterns

1. **HTML presentations as deliverables** — A single HTML file with embedded CSS is the fastest path from analysis to shareable artifact. Use a CSS system with `.slide`, `.data-table`, `.comparison-grid` classes. Renders everywhere, no dependencies, easy to iterate
2. **PPTX generation** — Use `python-pptx` to programmatically generate PowerPoint from analysis data. Create helper functions for slide layouts, then call them in sequence. Generates a professional deck in seconds. **Critical:** Always set slide dimensions to `Inches(13.333)` × `Inches(7.5)` (standard 16:9). Never convert HTML viewport pixels (1920×1080) to EMU — that creates a 20" × 11.25" canvas and content fills only ~66%. For complex visuals (SVG, dense grids), use a hybrid approach: native python-pptx for text-heavy slides, Playwright screenshots for visual slides
3. **Static site deployment** — Use a static hosting service (GitHub Pages, Netlify, Vercel, or internal tooling) to host HTML presentations. One command to deploy, instant sharing via URL
4. **Git worktrees for parallel work** — Use `git worktree add` to create separate directories for independent workstreams. Each worktree gets its own Claude session. Manage stash/merge carefully across worktrees. This is the biggest productivity unlock for multi-track PM work
5. **Product Catalog pattern** — Centralize analysis in a repo with `site/` (presentations), `topics/` (analysis docs), `scripts/` (generators), `topics/analytics/` (queries). This structure scales from 1 to 20+ analyses without becoming messy
6. **Google Docs table spacing fix** — When pasting HTML into Google Docs, tables get extra paragraph spacing in every cell (requiring manual "remove space before/after paragraph"). Google Docs wraps cell content in implicit `<p>` tags with default margins. Always add `td p, th p { margin: 0; line-height: inherit; }` to the CSS. For scoped table classes: `.data-table td p, .data-table th p { margin: 0; line-height: inherit; }`

## Advanced Patterns

### 1. The Throwaway Prototype Trap

Most PMs ask to "build a quick prototype" and then treat it as production code. Recognize the intent:

- **If they'll demo it once** → Single HTML file, hardcoded data, no error handling. Ship in 20 minutes.
- **If they'll use it weekly** → Add data persistence (localStorage, JSON file), basic input validation, and a clear "how to update" section.
- **If others will use it** → Add a README, handle edge cases, make configuration obvious. This is a real tool now.

The mistake is building category 3 when they need category 1. Ask: "Is this a one-time thing, or will you use it again?"

### 2. The Data-to-Deck Pipeline

PMs constantly need to turn analysis into presentations. The fastest reliable pipeline:

1. **Query** → Raw data (BigQuery, SQL, CSV)
2. **Transform** → Python/JS script that structures the data
3. **Render** → HTML presentation with embedded CSS (single file, no dependencies)
4. **Convert** → python-pptx for PowerPoint if needed (reuse the same data)

The key insight: never manually format slides. If the data changes, re-run the script. PMs who manually update slides spend 2 hours on formatting every time the data refreshes. PMs with a pipeline spend 2 minutes.

### 3. The "Build vs. Configure" Decision

Before writing code, check if the problem is already solved:

- **Need a form?** → Google Forms, Typeform, or Notion database — not a custom app
- **Need a dashboard?** → Grafana, Looker, or a shared Google Sheet with charts — not a custom dashboard
- **Need automation?** → Zapier, GitHub Actions, or a cron job with a shell script — not a custom service
- **Need a landing page?** → GitHub Pages with a single HTML file — not a React app

Only build custom when: (a) existing tools can't express your specific logic, (b) you need it to integrate with something proprietary, or (c) the iteration speed of custom code outweighs setup time.

### 4. The Incremental Delivery Pattern

Ship the smallest useful version, then layer features based on actual usage:

- **v0.1**: Hardcoded data, works on your machine, proves the concept
- **v0.2**: Real data source, handles the happy path
- **v0.3**: Error handling, edge cases people actually hit
- **v0.4**: Configuration, documentation, handoff-ready

Most PM tools never need to go past v0.2. The ones that do will tell you — users will ask for specific features. Don't anticipate; respond to pull.

### 5. The "Make It Obvious" Principle

PM-built tools fail not because they break, but because people can't figure out how to use them. For any tool others will touch:

- **Put the action first** — The main thing they need to do should be visible without scrolling
- **Use real examples, not placeholders** — "Enter your OKR" is useless; "Increase DAU by 15% (Q2)" shows the format
- **Show the output immediately** — If it's a generator, show a preview. If it's a dashboard, show sample data on first load
- **Make errors human** — "No data for Q3" not "TypeError: Cannot read property 'metrics' of undefined"

The test: can someone use it correctly without you explaining it? If not, the UI needs work, not a README.

## Process

1. **Clarify requirements** — What are we building? Who uses it?
2. **Propose approach** — Tech stack, architecture (keep simple)
3. **Build incrementally** — Core functionality first
4. **Test and iterate** — Fix issues as they arise
5. **Document minimally** — Just enough to maintain

## Examples

### Example 1: Internal Tool

**User:** Build me a simple dashboard to track our team's OKRs.

**Good Response:**

Let me clarify a few things:

- Where should this live? (Local HTML, web app, spreadsheet?)
- How many OKRs? (5? 50?)
- Who updates it? (Just you, or the team?)

For a quick v1, I'd suggest a **single HTML file** you can open locally or host anywhere:

```html
<!DOCTYPE html>
<html>
<head>
  <title>Team OKRs</title>
  <style>
    body { font-family: system-ui; max-width: 800px; margin: 2rem auto; }
    .objective { margin: 1.5rem 0; padding: 1rem; border-left: 4px solid #22c55e; }
    .kr { margin: 0.5rem 0 0.5rem 1rem; }
    .progress { background: #eee; border-radius: 4px; overflow: hidden; }
    .progress-bar { height: 8px; background: #22c55e; }
    .on-track { border-color: #22c55e; }
    .at-risk { border-color: #f59e0b; }
    .off-track { border-color: #ef4444; }
  </style>
</head>
<body>
  <h1>Sample Quarterly OKRs</h1>

  <div class="objective on-track">
    <h3>O1: Improve push notification engagement</h3>
    <div class="kr">
      <div>KR1: Increase delivery rate from 85% to 95%</div>
      <div class="progress"><div class="progress-bar" style="width: 70%"></div></div>
    </div>
    <div class="kr">
      <div>KR2: Reduce time-to-tap by 20%</div>
      <div class="progress"><div class="progress-bar" style="width: 45%"></div></div>
    </div>
  </div>

  <!-- Add more objectives here -->
</body>
</html>
```

This gives you:

- Visual progress bars
- Color-coded status (green/yellow/red)
- Easy to edit (just change the HTML)
- No dependencies or hosting needed

Want me to:

1. Add more objectives?
2. Make it editable (add a simple form)?
3. Add data persistence (localStorage)?

### Example 2: Automation Script

**User:** Create a script that pulls my calendar events and formats them as a daily standup summary.

**Good Response:**

I'll build this in Python. Quick questions:

- Google Calendar or Outlook?
- What format do you want? (Markdown, Slack message, plain text?)

Assuming Google Calendar + Markdown output:

```python
#!/usr/bin/env python3
"""Generate daily standup summary from Google Calendar."""

from datetime import datetime, timedelta
from google.oauth2.credentials import Credentials
from googleapiclient.discovery import build

def get_today_events():
    """Fetch today's calendar events."""
    creds = Credentials.from_authorized_user_file('credentials.json')
    service = build('calendar', 'v3', credentials=creds)

    today = datetime.now().date()
    start = datetime.combine(today, datetime.min.time()).isoformat() + 'Z'
    end = datetime.combine(today, datetime.max.time()).isoformat() + 'Z'

    events = service.events().list(
        calendarId='primary',
        timeMin=start,
        timeMax=end,
        singleEvents=True,
        orderBy='startTime'
    ).execute().get('items', [])

    return events

def format_standup(events):
    """Format events as standup summary."""
    output = [f"## Standup - {datetime.now().strftime('%B %d, %Y')}\n"]
    output.append("### Today's Schedule\n")

    for event in events:
        start = event['start'].get('dateTime', event['start'].get('date'))
        time = datetime.fromisoformat(start.replace('Z', '+00:00')).strftime('%H:%M')
        output.append(f"- **{time}** - {event.get('summary', 'No title')}")

    if not events:
        output.append("- No meetings scheduled")

    return '\n'.join(output)

if __name__ == '__main__':
    events = get_today_events()
    print(format_standup(events))
```

To use:

1. Set up Google Calendar API credentials
2. Run `python standup.py`
3. Copy output to Slack/standup doc

Want me to add:

- Yesterday's events (for "what I did")?
- Filtering (skip 1:1s, focus time blocks)?
- Direct Slack posting?

### Example 3: Analysis-to-Presentation Pipeline

**User:** I have BigQuery analysis results about push notification reachability. Build me a presentation I can share with leadership.

**Good Response:**

This is a multi-step pipeline. I'll build each piece:

**Step 1: HTML Presentation**

```html
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Push Reachability Analysis</title>
  <style>
    :root {
      --bg-primary: #121212;
      --text-primary: #ffffff;
      --brand-green: #22c55e;
      --accent-error: #ff3b30;
    }
    body { font-family: system-ui, sans-serif; background: var(--bg-primary); color: var(--text-primary); }
    .slide { min-height: 100vh; padding: 4rem 2rem; }
    .slide__title { font-size: 2rem; margin-bottom: 1rem; }
    .data-table { width: 100%; border-collapse: collapse; }
    .data-table th, .data-table td { padding: 0.75rem 1rem; text-align: left; border-bottom: 1px solid rgba(255,255,255,0.1); }
    .verdict { padding: 2px 8px; border-radius: 4px; font-size: 0.85rem; }
    .verdict--critical { background: rgba(255,59,48,0.2); color: #ff3b30; }
    .verdict--positive { background: rgba(34,197,94,0.2); color: #22c55e; }
    .comparison-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 2rem; }
  </style>
</head>
<body>
  <section class="slide">
    <h2 class="slide__title">The Finding</h2>
    <table class="data-table">
      <tr><td>iOS Reachability</td><td><strong>39.8%</strong></td></tr>
      <tr><td>Android Reachability</td><td><span class="verdict verdict--critical">21.9%</span></td></tr>
    </table>
  </section>
  <!-- Add more slides... -->
</body>
</html>
```

**Step 2: PPTX Generation Script**

```python
from pptx import Presentation
from pptx.util import Inches, Pt, Emu

def build_data_slide(prs, title, rows):
    slide = prs.slides.add_slide(prs.slide_layouts[5])
    slide.shapes.title.text = title
    table = slide.shapes.add_table(len(rows)+1, 3, ...).table
    for i, (label, ios, android) in enumerate(rows):
        table.cell(i+1, 0).text = label
        table.cell(i+1, 1).text = str(ios)
        table.cell(i+1, 2).text = str(android)
    return slide

prs = Presentation()
build_data_slide(prs, "Reachability by Platform", [
    ("Overall", "39.8%", "21.9%"),
    ("Free Tier", "34.2%", "18.1%"),
])
prs.save("reachability-analysis.pptx")
```

**Step 3: Deploy**

```bash
npx gh-pages -d site  # Or: netlify deploy --prod, vercel --prod
```

This gives you:

- HTML presentation for browser viewing (shareable via URL)
- PPTX for meetings and email
- Both generated from the same data

Want me to:

1. Add more slides with your specific data?
2. Add interactive charts (Chart.js)?
3. Create a reusable template for future analyses?

## Prerequisites

- Claude Code with file write access
- Project context or requirements for what to build
- Target environment details (browser, Node.js, Python, etc.) if applicable

## Output

Working code artifacts including HTML presentations, automation scripts, data pipelines, internal tools, and deployment-ready prototypes with minimal documentation.

## Error Handling

If requirements are ambiguous, ask clarifying questions before building. When a build fails, diagnose the root cause and fix iteratively rather than starting over. If the requested tool exceeds reasonable scope, propose a simpler v1 and outline the path to the full version.

## Resources

- [python-pptx documentation](https://python-pptx.readthedocs.io/) -- programmatic PowerPoint generation
- [GitHub Pages](https://pages.github.com/) -- static site hosting for HTML deliverables
- [Git Worktrees](https://git-scm.com/docs/git-worktree) -- parallel workstream management
Files in this package (2)
  • SKILL.md 15 KB
  • references/evidence-and-review.md 1 KB

Versions

RepositoryScoreLicence
This page · jeremylongshore/tons-of-skills-marketplace100MIT
Tristan578/project-forge100Apache-2.0
grimoire-rs/grimoire90Apache-2.0
tomaspozo/agentlink90MIT

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 439469240a5c (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100game-prototype-builder
    Unity / Godot Prototype Builder: When project files and execution tools exist, verify the installed engine and run the engine build. Use when the user asks for unity / godot prototype builder work, or mentions game, prototype, builder.
  • 100personal-tool-builder
    Expert in building custom tools that solve your own problems first. The best products often start as personal tools - scratch your own itch, build for yourself, then discover others have the same itch. Covers rapid prototyping, local-first apps, CLI tools, scripts that grow into…
  • 91add-tool
    Scaffold a new MCP tool definition. Use when the user asks to add a tool, create a new tool, or implement a new capability for the server.
  • 100prototype-workflow
    Manage frontend prototype development workflow under the `prototypes/` directory. This skill enforces a strict development process for both **new prototype creation** and **existing prototype modification**. Trigger whenever the user mentions: - "新建原型" / "create a new prototype"…
  • 90full-app-build
    Build and iterate on a full real app from Design, backed by a running Builder Fusion cloud container instead of an inline HTML prototype. Use when the user wants a real/full app end-to-end through publishing, and only when FULL_APP_BUILDING_ENABLED is true.
  • 100playable-prototype
    Turns game design documents into playable, testable browser prototypes, and fixes prototypes that look generic or "AI-made" (AI slop: landing-page title, app-like HUD, web fonts) so they look like real games. Produces a single-file HTML5 game whose numbers come straight from the…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.