Forem: nghiahsgs

I built a Claude Code skill that generates 50,000+ unique slide designs — and killed the "AI slop" aesthetic

nghiahsgs — Wed, 01 Apr 2026 07:41:51 +0000

Stop Making Purple Slides: I Built a Token-Based Design System for Claude Code

You know the look. Every AI-generated presentation has it:

Purple gradient on white background
Inter font on everything
Identical box-shadow on every element
Flat solid backgrounds with zero depth
No visual hierarchy whatsoever

I got tired of it. So I built skills-slides — a Claude Code skill with a token-based design system that makes it impossible to generate generic slides.

nghiahsgs / skills-slides

50,000+ unique HTML presentation designs. Zero dependencies. Anti-AI-slop. A Claude Code skill.

slides

A Claude Code skill that generates stunning HTML presentations. Zero dependencies. Works offline. Opens in any browser.

50 aesthetics × 20 palettes × 10 fonts × 5 layouts × 30+ effects = 50,000+ unique design combinations.

Every presentation ships as a single .html file — no build step, no npm, no PowerPoint. Just double-click to present.

Live Demo →

Why this exists

AI-generated slides look the same: purple gradients, Inter font, identical shadows, flat backgrounds. This skill fights that with a token-based design system and a strict anti-slop checklist that catches generic patterns before delivery.

The result: presentations that look intentionally designed, not template-generated.

What's inside

tokens/              # The design system
├── aesthetics.csv       # 50 named styles (startup-pitch, neon-cyber, editorial-minimal...)
├── color-palettes.csv   # 20 palettes with full hex values + WCAG ratios
├── font-pairings.csv    # 10 curated pairs from Google Fonts & Fontshare
├── layout-patterns.csv  # 5 CSS grid

…

View on GitHub

How it works

Instead of letting the AI freestyle (and default to purple gradients), every presentation is built from curated design tokens:

50 aesthetics × 20 palettes × 10 fonts × 5 layouts × 30+ effects = 50,000+ unique combinations

You describe a vibe. The search engine finds matching tokens. You pick a direction. Claude generates a single .html file.

What's in the token library?

50 aesthetics: From startup-pitch to neon-cyber, editorial-minimal to terminal-hacker. Each one defines which palettes, fonts, layouts, and effects are compatible.
20 color palettes: Full systems with bg, surface, text, accents, borders, and glow. Every palette ships with WCAG contrast ratios already verified.
10 font pairings: Curated display + body pairs from Google Fonts and Fontshare. No Inter. No Roboto. No system-ui.
30+ effects: Particles, aurora, gradient mesh, glassmorphism, grid overlay, magnetic cursor, 3D tilt. Complete CSS + JS snippets for each.

The Output

Every presentation is a single self-contained HTML file with:

✅ Keyboard navigation (arrows, space, escape)
✅ Responsive sizing with clamp() — works on any screen
✅ Full ARIA labels and semantic HTML
✅ prefers-reduced-motion support
✅ Optional in-browser editing (double-click any text)
✅ PDF export via Chrome headless

No frameworks. No dependencies. Works offline. Works forever.

Quick Start

Clone into Claude Code skills directory:


bash
git clone [https://github.com/nghiahsgs/skills-slides.git](https://github.com/nghiahsgs/skills-slides.git) ~/.claude/skills/slides

I Built an AI Agent That Governs Itself — Separation of Powers for LLMs

nghiahsgs — Mon, 23 Mar 2026 11:08:21 +0000

Most AI agents today work like interns with root access — powerful but ungoverned. They can call any tool, access any file, and execute any command. We trust them because... well, we hope the LLM "knows better."

I didn't like that. So I built LawClaw — an AI agent governed by a separation of powers framework, inspired by constitutional law.

The Problem

Every AI agent framework I've seen treats governance as an afterthought:

"Just add a system prompt telling it not to do bad things"
"Use a content filter on the output"
"Hope the model is aligned enough"

This is like running a country with no laws, no courts, and no constitution — just a king who promises to be good.

The Architecture: Three Branches of Power

LawClaw implements three distinct governance layers:

1. Constitution (Immutable Rules)

A constitution.md file that cannot be modified by the agent itself. It defines:

Fundamental rights of the owner
Boundaries of power (what the agent SHALL NOT do)
Resource limits (execution timeouts, iteration caps)
Transparency requirements (audit trails)

2. Legislative Branch (Laws)

Detailed laws that the owner can create, update, or repeal:

Conduct Law: How the agent communicates and behaves
Privacy Law: Data handling rules
Safety Law: Dangerous operation restrictions

These are more flexible than the constitution — the owner can adjust them as needs change.

3. Pre-Judicial Branch (Automated Enforcement)

A judicial layer that intercepts every tool call before execution and checks it against the constitution and laws. Think of it as automated traffic cameras:

Agent tries to delete critical files? Blocked.
Agent tries to expose an API key? Blocked.
Agent tries to modify the constitution? Blocked.

The agent doesn't need to be trusted. It needs to be governed.

Why This Matters

As AI agents get more capable, the question isn't "can we make them smarter?" — it's "can we make them accountable?"

With traditional approaches, you're relying on the LLM's training to avoid dangerous actions. With separation of powers, you have structural guarantees — the judicial branch blocks dangerous actions regardless of what the LLM "decides."

Key Design Principles

1. The agent cannot modify its own governance
Just like a citizen can't rewrite the constitution, LawClaw cannot edit its own rules. Only the human owner can.

2. Laws are transparent and auditable
Every tool call is logged. The owner can review the full audit trail at any time. No black boxes.

3. Enforcement is automated, not advisory
The judicial branch doesn't "suggest" blocking a dangerous action — it vetoes it. The agent then reports what happened transparently.

4. Separation prevents concentration of power
No single layer controls everything. The constitution limits the laws. The laws guide the agent. The judiciary enforces both.

What LawClaw Can Do (Within Its Laws)

Browse the web and research topics
Control a Chrome browser (with persistent sessions)
Manage cron jobs for scheduled tasks
Send and receive emails
Execute shell commands (within safety limits)
Work with git repos, create PRs, merge code
Fetch real-time data (crypto prices, weather, news)
Create 3D scenes with Blender
Write, edit, and debug code

All of this — governed. Every action checked. Every dangerous pattern blocked.

The Insight

We've spent thousands of years developing governance frameworks for humans. Constitutions, laws, courts, checks and balances — these aren't bugs in human civilization. They're features.

AI agents need the same thing. Not better prompts. Not bigger models. Better governance.

The agent doesn't need to be trusted. It needs to be governed.

LawClaw is a governed AI agent running as a Telegram bot. If you're interested in the separation of powers approach to AI agent safety, I'd love to hear your thoughts in the comments.

I built an open-source "focus group simulator" that spawns 1,000 AI customers to roast your startup idea

nghiahsgs — Mon, 16 Mar 2026 06:29:54 +0000

The Problem

Every founder has been there: you spend 3 months building something, launch it, and... crickets. Nobody wants it.

User interviews cost time. Landing page A/B tests cost money. Survey panels cost both.

What if you could get brutally honest feedback from 1,000 potential customers in 2 minutes?

What I Built

Sybil Swarm is an open-source swarm intelligence engine. You feed it your product URL or description, and it:

Spawns 1,000 AI agents — each with a unique persona (age, job, income, personality, interests)
Has them evaluate your product as real potential customers
Generates a market prediction report with conversion rate, objections, and recommendations

The name comes from the Sibyls — prophetic oracles of ancient Greece.

Demo

The Dashboard

The simulation runs in real-time with:

Canvas world — agents move around, cluster by sentiment (buyers → right, rejectors → left)
Sentiment heatmap — fills up red/yellow/green as agents complete
Live feed — Twitter-like stream of agent reactions
Conversion funnel — Aware → Interested → Willing to Pay → Would Buy

## What the Report Looks Like

The AI synthesis agent writes a brutally honest market prediction:

Market Viability Score (0-100)
Conversion rate prediction
Top objections (what's killing your product)
Top suggestions (what would make people buy)
Go/No-Go recommendation

One of my test runs came back: "AgriBeacon is not viable in its current form. 0% conversion rate. Its value proposition is a
marketing mirage." Ouch. But exactly what I needed to hear.

## Tech Stack

Backend: Python FastAPI, async parallel agent evaluation
Frontend: Next.js 16, Canvas 2D, Framer Motion
LLM: Any OpenAI-compatible API (works with free Alibaba Qwen tier)
No agent framework — just async batch LLM calls with semaphore. CrewAI/LangGraph are overkill for this.

## Try It


bash
  git clone https://github.com/nghiahsgs/Sybil-Swarm.git
  cd Sybil-Swarm
  # Set up your API key (Qwen free tier works!)
  cp .env.example .env
  # Install & run
  cd backend && pip install -e . && uvicorn app.main:app --port 8000 &
  cd ../frontend && npm install && npm run dev

  Open http://localhost:3000 → paste your URL → Launch Simulation

  Is This Actually Useful?

  Honestly? It's not a replacement for talking to real humans. But it's a cheap, fast pre-filter:

  - If 0% of simulated customers would buy → strong signal to pivot
  - If 40%+ would buy → worth investing in real validation
  - The objections list alone is worth it — things you didn't think of

  What's Next

  - Chat with individual agents post-simulation (already built)
  - More provider support (OpenAI, Anthropic, Google, Qwen)
  - Deploy as hosted service

  GitHub: https://github.com/nghiahsgs/Sybil-Swarm

  MIT license. Stars appreciated!

  ---