Mert

A full walkthrough of building a CNN-powered web app that identifies 7 types of skin lesions and detects monkeypox from uploaded images — with AI-generated medical explanations.

What if you could upload a photo of a skin lesion and get an AI-powered prediction in under 2 seconds — no signup, no data stored, completely free?

That’s exactly what I built for my capstone thesis. SKIN is a web app that runs two CNN models: a 7-class skin lesion classifier trained on the HAM10000 dataset, and a binary monkeypox detector. It also uses Groq’s Llama 4 Scout to generate plain-language medical explanations for each prediction.

Here’s how I built it.

Live Demo | GitHub Repo

Notion Is Not Just a Note App

Notion API lets you programmatically read, create, and update pages, databases, and blocks. Free for personal use, included in all plans.

Setup

1. Go to notion.so/my-integrations
2. Create new integration
3. Copy the API key
4. Share your database/page with the integration

import requests

TOKEN = "your_notion_api_key"
HEADERS = {
    "Authorization": f"Bearer {TOKEN}",
    "Content-Type": "application/json",
    "Notion-Version": "2022-06-28"
}

Query a Database

def query_database(db_id, filter_obj=None):
    data = {}
    if filter_obj:
        data["filter"] = filter_obj
    r = requests.post(f"https://api.notion.com/v1/databases/{db_id}/query",
                      headers=HEADERS, json=data)
    results = r.json()["results"]
    return [{"id": p["id"], "props": {k: v for k, v in p["properties"].items()}}
            for p in results]

# Get all items where Status = "Done"
items = query_database("your_db_id", {
    "property": "Status",
    "status": {"equals": "Done"}
})

Create a Page

def create_page(db_id, title, status="Not started"):
    data = {
        "parent": {"database_id": db_id},
        "properties": {
            "Name": {"title": [{"text": {"content": title}}]},
            "Status": {"status": {"name": status}}
        }
    }
    r = requests.post("https://api.notion.com/v1/pages",
                      headers=HEADERS, json=data)
    return r.json()["id"]

page_id = create_page("db_id", "New task from Python")

Add Content to a Page

def add_blocks(page_id, blocks):
    r = requests.patch(f"https://api.notion.com/v1/blocks/{page_id}/children",
                       headers=HEADERS, json={"children": blocks})
    return r.json()

add_blocks(page_id, [
    {"type": "heading_2", "heading_2": {
        "rich_text": [{"text": {"content": "Summary"}}]
    }},
    {"type": "paragraph", "paragraph": {
        "rich_text": [{"text": {"content": "This was created via the API."}}]
    }},
    {"type": "bulleted_list_item", "bulleted_list_item": {
        "rich_text": [{"text": {"content": "First point"}}]
    }}
])

Real Automation Ideas

1. Daily standup bot — create a page every morning with template
2. CRM — add leads from email/forms directly to Notion database
3. Content calendar — sync Dev.to articles to Notion tracker
4. Project dashboard — aggregate data from multiple databases
5. Meeting notes — auto-create pages with attendees and agenda

Rate Limits

• 3 requests per second per integration
• No daily limit
• Pagination for large databases (100 items per page)

More API tutorials | GitHub

Why Telegram Bot API Is Special

Most APIs make you fight with OAuth, rate limits, and pagination. Telegram Bot API gives you a simple HTTP interface with instant webhooks, no OAuth, and generous limits.

Create a Bot in 60 Seconds

1. Open Telegram, search for @botfather
2. Send /newbot
3. Choose a name and username
4. Copy the API token

Done. No OAuth app registration, no redirect URIs, no client secrets.

Send a Message

import requests

TOKEN = "your_bot_token"
BASE = f"https://api.telegram.org/bot{TOKEN}"

def send_message(chat_id, text):
    r = requests.post(f"{BASE}/sendMessage", json={
        "chat_id": chat_id, "text": text, "parse_mode": "HTML"
    })
    return r.json()["ok"]

send_message("your_chat_id", "<b>Hello</b> from Python!")

Get Updates (Polling)

def get_updates(offset=0):
    r = requests.get(f"{BASE}/getUpdates", params={"offset": offset, "timeout": 30})
    return r.json()["result"]

# Simple bot loop
offset = 0
while True:
    updates = get_updates(offset)
    for u in updates:
        msg = u.get("message", {})
        text = msg.get("text", "")
        chat_id = msg["chat"]["id"]

        if text == "/start":
            send_message(chat_id, "Welcome! I am your bot.")
        elif text == "/help":
            send_message(chat_id, "Commands: /start, /help, /ping")
        elif text == "/ping":
            send_message(chat_id, "Pong!")

        offset = u["update_id"] + 1

Send Files, Photos, Locations

# Send a photo
def send_photo(chat_id, photo_url, caption=""):
    requests.post(f"{BASE}/sendPhoto", json={
        "chat_id": chat_id, "photo": photo_url, "caption": caption
    })

# Send location
def send_location(chat_id, lat, lon):
    requests.post(f"{BASE}/sendLocation", json={
        "chat_id": chat_id, "latitude": lat, "longitude": lon
    })

# Send a document
def send_document(chat_id, file_url):
    requests.post(f"{BASE}/sendDocument", json={
        "chat_id": chat_id, "document": file_url
    })

Inline Keyboards (Buttons)

def send_with_buttons(chat_id, text, buttons):
    keyboard = {"inline_keyboard": buttons}
    requests.post(f"{BASE}/sendMessage", json={
        "chat_id": chat_id, "text": text, "reply_markup": keyboard
    })

send_with_buttons("chat_id", "Choose an option:", [
    [{"text": "Option A", "callback_data": "a"}, 
     {"text": "Option B", "callback_data": "b"}],
    [{"text": "Visit Website", "url": "https://example.com"}]
])

Real Bot Ideas

1. Server monitor — send alerts when CPU/memory spikes
2. Daily digest — summarize news/data every morning
3. Expense tracker — log expenses by sending messages
4. Deployment notifier — alert on successful/failed deploys
5. RSS reader — forward new articles from your favorite blogs

Why Not Discord/Slack?

More API tutorials | GitHub

Building Disk Images Without Root (And Without Regret)

If you have built enough disk images, you eventually hit the same Rite Of Passage:

It is 1:27 AM, you are tired, and you want run a fast “one-liner” with sudo dd or sudo mkfs.fat.
You falsely typed one character.
You did not wipe the test image.
You wipe a host partition.

That story is so common it might as well be onboarding material.

The trap is not triggered because low-level tools are bad. But because the trap is running low-level tools with maximum privilege on the host, in a workflow with high typo probability and weak guardrails.

This guide is about building bootable disk images in User Space while keeping Host Safety intact. And not get your host disk ruined.

Failure Mode: The Root Workflow Drift

Most people start with this pattern because it looks “standard”:

# 1) Create a blank disk image
dd if=/dev/zero of=disk.img bs=1M count=512

# 2) Partition it
parted -s disk.img mklabel msdos mkpart primary fat32 1MiB 100%

# 3) Bind with a loop device
loop_dev=$(sudo losetup -fP --show disk.img)

# 4) Make filesystem + mount + copy
sudo mkfs.fat -F 32 "${loop_dev}p1"
mkdir -p ./mnt
sudo mount "${loop_dev}p1" ./mnt
sudo cp -r ./payload/. ./mnt/
sudo umount ./mnt
sudo losetup -d "${loop_dev}"

Nothing here is unusual. That is exactly why it is dangerous, because what you think is not dangerous could be very dangerous. This sequence normalizes a habit where every critical operation uses sudo, so one typo has host-level blast radius.

The Hierarchy of Hazard

Use a Symptom Vs Catastrophe model when evaluating root-heavy image workflows.

Tier 1: Annoying Symptom

• Wrong partition offset in dd.
• Files copied into the wrong path.
• Disk not booting due to broken VBR.

These are fixable and mostly local to the image artifact.

Tier 2: Costly Symptom

• Loop device leaks because losetup -d was skipped.
• Confusing /dev/loopN state after repeated runs.
• CI/CD scripts becoming non-deterministic.

Now your workflow degrades over time and debugging cost increases.

Tier 3: Catastrophe

• mkfs points to a host partition instead of the image.
• dd writes to the wrong block device.
• grub-install targets host storage after device resolution fails.

At this tier, you are no longer “debugging an image.” You are performing incident response on your own workstation.

What Usually Breaks First

Loopback Device Lifecycle

What Breaks

Loop devices accumulate when scripts exit early or cleanup paths are missed. Eventually your flow depends on stale /dev/loopN state and implicit assumptions about which loop index maps to which file.

Why it Matters

Your build stops being deterministic. On a good day it “works on my machine”. On a bad day it formats the wrong target because loop_dev is not what your script thinks it is.

GRUB Target Resolution

What Breaks

grub-install is called with an invalid or unexpected target device, then falls back to behavior you did not intend, GRUB will fallback to your host disk if the disk you specified to GRUB does not exist.

Why it Matters

Bootloader writes are destructive by design. A mis-targeted install can modify host boot configuration and convert a test run into a host recovery task.

Three User Space Strategies

The goal is simple: no mount(2), no host loop device dependency for routine file operations, and minimal root privilege.

Option 1: Libguestfs (guestfish)

guestfish builds and edits disk images inside an appliance VM. That isolation is the key safety property.

guestfish << 'EOF'
sparse disk.img 512M
run
part-init /dev/sda mbr
part-add /dev/sda p 2048 -1
mkfs vfat /dev/sda1
mount /dev/sda1 /
copy-in payload/. /
sync
quit
EOF

Pros

• Strong Host Safety boundary because operations happen in a guest appliance.
• Scriptable for CI with stable command primitives.
• Good default for “just make me a bootable image” pipelines.

Cons

• Slower on weak hosts because all I/O is VM-mediated.
• Kernel/appliance setup can be brittle on some distros.
• FAT behavior can become MysteryMeat in edge sizes.

On that FAT point: mkfs vfat may auto-select FAT12/FAT16/FAT32 based on partition geometry. You can end up with a FAT16-style VBR while the partition type marker says 0x0c (FAT32 LBA). The image is technically “built,” but tooling assumptions diverge and boot behavior becomes inconsistent, if you have your own OS, it may be a problem.

When to use this

Use when you want maximum safety and can tolerate lower build speed, it is also good when you want maximum customizability.

Option 2: DiskCombining (Assemble Image Segments)

This method creates partition payloads separately, then injects them into a pre-partitioned disk image. It favors explicit geometry control and reproducibility.

disk_size_mb=512
part_size_mb=511
part_start_lba=2048

dd if=/dev/zero of=disk.img bs=1M count="${disk_size_mb}"

# Create partition table non-interactively
parted -s disk.img mklabel msdos
parted -s disk.img mkpart primary fat32 1MiB 100%

# Build partition payload independently
dd if=/dev/zero of=part.img bs=1M count="${part_size_mb}"
mkfs.fat -F 32 part.img

# Populate partition payload using user-space FAT tools
mmd -i part.img ::/boot
mcopy -i part.img kernel.bin ::/boot/kernel.bin

# Inject partition payload at the partition start
dd if=part.img of=disk.img bs=512 seek="${part_start_lba}" conv=notrunc

# Set partition type to W95 FAT32 (LBA)
printf 'x0c' | dd of=disk.img bs=1 seek=450 conv=notrunc

Pros

• Maximum control over geometry, offsets, and byte-level layout.
• Fast and deterministic once script variables are correct.
• Works well for advanced boot experiments.

Cons

• Higher cognitive load; offset math mistakes are easy.
• MBR-first workflows are simpler here than GPT-first workflows.
• You own all correctness checks.

When to use this

Use when you need precise layout control and are comfortable validating disk geometry manually.

Option 3: mtools-First FAT Workflow

This is the most underrated path for FAT boot media. Use mtools to manipulate filesystems entirely in UserSpace.

# Create FAT image file directly
dd if=/dev/zero of=part.img bs=1M count=64
mkfs.fat -F 32 part.img

# No mount syscall required
mmd -i part.img ::/EFI
mmd -i part.img ::/EFI/BOOT
mcopy -i part.img BOOTX64.EFI ::/EFI/BOOT/BOOTX64.EFI

Pros

• mcopy and mmd operate without mount, so no root requirement for file operations.
• Cleaner CI scripting because there is no loop device lifecycle to manage.
• Excellent for FAT payload staging before final disk assembly.

Cons

• Primarily useful for FAT workflows; not a universal filesystem toolkit.
• Less familiar to developers used to mount + cp habits.
• You still need a partitioning plan for full-disk images.

When to use this

Use when your target is FAT-based boot media and you want the safest day-to-day developer loop.

Practical Verdict

• If you optimize for Safety First: choose guestfish.
• If you optimize for Layout Control: choose Disk Combining.
• If you optimize for daily velocity on FAT images: choose mtools + assembly.

My default in real projects is hybrid:

1. Use mtools for payload edits.
2. Use Disk Combining for reproducible final image assembly.
3. Keep guestfish as the “safe fallback” when environment-specific tools become noisy.

This keeps the core loop in UserSpace while preserving deep control when needed.

Conclusion

Root privileges are not a badge of low-level skill. They are a liability multiplier.

If your disk workflow requires frequent sudo, you are one typo away from turning a build task into a recovery task. Shift routine image operations to UserSpace, isolate risky steps, and reserve privilege for the rare places where it is truly necessary.

Experiments & Resources

I spend roughly 6 hours a week outside my main work researching these systems performance bottlenecks and refining my build toolchain. For those building for unpackage, I’ve packaged my advanced, rootless disk-building scripts—along with the full source for this experiment into the latest code bundle on my Support page. It’s the fastest way to move from this theory to a repeatable production pipeline.

How we solved multi-agent skill sprawl, built persistent memory across tools, and automated cloud sync — and why we’re open-sourcing all of it.

If you’re working with more than one AI coding agent right now — and most serious teams are — you’ve already felt the friction. You invest real time dialing in a set of custom skills or instructions for Claude Code. You switch to Codex. You open Cursor. You ask Perplexity Computer something. And every single one of those tools has its own isolated context. Your carefully tuned knowledge about N+1 traps in complex has_many eager loads, your hard-won patterns for zero-downtime Rails migrations, your pgvector HNSW tuning notes — gone. Each new session, each new tool, you’re explaining the same things from scratch.

We ran into this while building OpenSite AI, and we eventually got fed up enough to solve it properly. Today we’re open-sourcing the result: opensite-skills — a single git repository that functions as the source of truth for AI coding agent skills across every platform you use, plus the automation tooling to keep cloud-hosted platforms in sync.

What the Problem Actually Looks Like

The naive solution to multi-agent skill drift is copy-paste. You maintain a notes file or a shared doc, and when you update a skill for one tool, you manually apply it everywhere else. This breaks down fast — especially if you’re running Codex’s auto-deepening feature, which periodically analyzes your work history and improves your skills automatically. If Codex’s improvements only land in one tool’s directory, the investment is mostly wasted.

The deeper problem is that there’s no API. Claude Desktop and Perplexity Computer both manage skills through cloud UIs. Neither platform exposes a REST API for skill uploads. Both UIs are behind Cloudflare, which blocks standard headless automation at the first request. Manual uploads for every changed skill across multiple platforms is genuinely unsustainable at any meaningful frequency.

We needed something that could:

1. Keep every local agent (Claude Code, Codex, Cursor, Copilot) wired to the same skill set with zero copying
2. Automate cloud uploads for Claude Desktop and Perplexity Computer without manual UI work
3. Detect and push only changed skills rather than re-uploading everything every time
4. Persist project knowledge, conventions, and decisions across sessions and across tools

The Architecture: Symlinks as the Foundation

For local platforms, the solution is almost embarrassingly simple: symlinks. Run ./setup.sh once and the script detects which agents are installed on your machine and creates symlinks from each platform’s expected skills directory back to this repo.

git clone [email protected]:opensite-ai/opensite-skills.git ~/opensite-skills
cd ~/opensite-skills
./setup.sh

That’s the entire local setup. The script walks your system, finds Claude Code (~/.claude), Codex (~/.codex), Cursor (~/.cursor), and GitHub Copilot (~/.copilot or the gh CLI), and creates the appropriate symlinks. No file copying, no config to maintain.

Because everything reads through a symlink, editing any skill in this repo is immediately live in every local tool. There is no reinstall step. This also means when Codex deepens a skill and writes back to ~/.codex/skills/, that write lands directly in this git repo. Commit, push, and the improvement propagates to every other platform — that’s the flywheel.

# After a Codex deepening session
cd ~/opensite-skills
git add -A
git commit -m "chore(skills): codex deepening $(date +%Y-%m-%d)"
git push

# Then push only changed skills to cloud platforms
./sync-perplexity.sh --changed-only
./sync-claude.sh --changed-only

Solving the Cloud Sync Problem with Playwright

The harder problem is Claude Desktop and Perplexity Computer. Neither has a public API. Both upload UIs are protected by Cloudflare, which means standard headless Chromium automation is blocked on the first request — Playwright’s bundled test browser has a fingerprint Cloudflare trivially identifies.

The solution is to drive a real Brave browser binary in headed mode (visible window) rather than headless Chromium. A real browser with a real fingerprint passes Cloudflare’s bot checks. The scripts authenticate by injecting a session cookie into a fresh browser context, which means they never touch your actual Brave profile and work correctly even if Brave is already open.

Getting your session cookie is a one-time, 30-second process:

1. Log into the target site in Brave
2. Press F12 → Application → Cookies
3. Find the session token (details differ per platform — the README has exact field names)
4. Add it to .env

Then sync runs in one command:

./sync-perplexity.sh                    # all skills
./sync-perplexity.sh --changed-only     # git-diff-based delta push
./sync-perplexity.sh rails-query-optimization  # one specific skill

./sync-claude.sh                        # all skills
./sync-claude.sh --changed-only
./sync-claude.sh rust-error-handling    # one specific skill

One non-obvious technical detail worth flagging if you build anything similar: the file upload mechanism matters. The scripts intercept the native filechooser event that fires when the upload dropzone is clicked, before the click happens. Directly setting input.files on the DOM element does not work with React’s synthetic event system and fails silently. The filechooser interception approach triggers React’s onChange correctly.

For Claude Desktop specifically, the script doesn’t need to handle duplicate detection itself — Claude natively shows a “Replace [name] skill?” confirmation dialog when a skill with the same name already exists. The script just clicks “Upload and replace” and continues. Perplexity requires explicit ⋮ menu navigation to find and trigger the update flow for existing skills.

The Skills: What’s in the Library

The skills span the full stack of patterns that matter for modern web application development. Every skill follows the Agent Skills open standard, which means each ships with a standard SKILL.md (description, compatibility, metadata), an agents/openai.yaml for Codex UI metadata, and a references/activation.md with a portable activation guide.

Memory System

Four skills that work as a unit to give any AI engine persistent long-term context using only the local filesystem — no external services, no databases:

The store is organized into four cognitive layers: episodic (session history and milestones), semantic (project facts, tech notes, user preferences), procedural (ADRs, workflows, code conventions), and working (the active.md hot handoff between sessions).

Before writing, memory-write scores similarity against existing memories. Scores above 0.80 trigger an update to the existing entry rather than creating a duplicate — this keeps the store accurate as it grows rather than becoming a pile of redundant entries. All store data is gitignored and lives only on your local machine.

AI / Research

ai-research-workflow covers multi-step AI pipeline orchestration: WorkflowBuilder/WorkflowStep system design, dual-model routing (Opus for deep research and web search, Sonnet for structured generation), parallel step execution, and shared MemoryStore between steps.

ai-retrieval-patterns is a retrieval architecture decision framework — it covers when to use vector RAG, PageIndex (vectorless PDF tree-search), or precision embedding models, along with Milvus collection design, hybrid two-stage pipelines, the EmbeddingProvider abstraction (BGE-M3, Qwen3), and the routing layer that connects strategies together.

Frontend

react-rendering-performance targets React 19+ specifically: React Compiler diagnostics, profiler-driven optimization workflows, useTransition for non-blocking updates, the Activity and ViewTransition components, resource preloading APIs, and evidence-based guidance on when to actually reach for useMemo and useCallback vs. just letting the Compiler handle it.

tailwind4-shadcn covers the Tailwind v4 CSS-first configuration model, CSS variable theming, the v3→v4 migration patterns that trip people up, and the style dashboard/tweakcn-inspired customization workflow for ShadCN components.

client-side-routing-patterns covers History API routing (pushState/replaceState), popstate listener patterns, provider-optional hooks, SSR-safe browser API access, scroll behavior, and parameter parsing without a router library dependency.

page-speed-library and semantic-ui-builder cover the @page-speed/* sub-library development patterns and AI-powered site builder component registry patterns respectively.

opensite-ui-components covers @opensite/[email protected] — Semantic UI Engine, block/skin architecture, Radix UI composition, framer-motion, and the component registry system.

Rails / Backend

rails-query-optimization goes beyond basic includes into the less-documented failure modes: the cartesian product trap when you eager-load multiple has_many associations on the same parent, CTEs and lateral joins via Arel and raw SQL, reading EXPLAIN ANALYZE output at a level that lets you actually diagnose plan instability, and counter cache patterns.

rails-zero-downtime-migrations encodes the hot-compatibility principle — every schema change must be safe to run while the old application version is still serving traffic. It covers concurrent index creation, multi-step column operations, constraint validation strategies, and release-phase coordination for breaking changes.

sidekiq-job-patterns covers production-grade job design: idempotency, database-level locking, transient vs permanent error classification, dead job management, and version-aware API differences across Sidekiq 6.5.x through 8.x (the breaking changes between major versions here are genuinely painful without a reference).

Rust / Backend

rust-async-patterns tackles the senior-level async Rust problems: Future Send bound failures and how to trace them, Rust 2024 lifetime capture rules that affect async closures, task cancellation with CancellationToken, blocking/async boundary design, and timeout composition with Tokio.

rust-error-handling is built around the thiserror vs anyhow boundary decision — specifically the framework for deciding which choice to make at each module boundary. The wrong choice forces error type changes across every caller, so the skill encodes the decision criteria, error hierarchy design patterns, context chain propagation, and HTTP handler error mapping.

Database / Performance

pgvector-optimization covers HNSW vs IVFFlat index selection and tuning, the ef_search/m/ef_construction parameter relationships, iterative scanning for filtered queries, and scalar and binary quantization for reducing memory footprint.

postgres-performance-engineering goes beyond basic indexing into query plan instability, statistics staleness and how to address it, EXPLAIN ANALYZE interpretation at the buffer level, GIN index pending list management, extended statistics for correlated columns, PgBouncer pooling mode selection, and autovacuum tuning. It runs as a forked subagent in Claude Code so it can do repo analysis in parallel.

DevOps / Operations

automation-builder encodes the Playwright + real browser patterns that underpin the cloud sync scripts themselves: browser fingerprint strategy, session cookie injection, SPA readiness detection, React filechooser upload flow, error recovery in upload loops, shell script safety patterns, and media tool selection (ffmpeg, ImageMagick, Sharp).

agent-file-engine covers root and nested AGENTS.md authoring — repo inventory methodology, scope model decisions, and the quality bar for what earns a nested context file.

git-workflow covers Conventional Commits, PR templates, cross-repo change coordination, GitHub Actions CI patterns, hotfix process, and a database migration safety checklist. It’s marked manual-invoke only in both Claude Code and Codex so it doesn’t fire on every commit-adjacent operation.

Quality / Security

code-review-security runs as a forked subagent in Claude Code for parallel PR analysis. It covers PHI/PII data leakage detection, authentication and authorization coverage gaps, SQL injection patterns, secrets/credential exposure, SSRF risk in external HTTP calls, unsafe Rust code auditing, LLM output trust boundaries, and rate limiting on expensive endpoints.

Platform Conventions That Cross All Tools

One of the more useful things about having a single library is that it enforces consistency across tools at the level of conventions, not just instructions. These are the platform-wide rules that every skill in the repo reinforces:

• Real browser for bot-protected SPAs — Playwright with a real Brave/Chrome binary in headed mode for any site behind Cloudflare. Headless Chromium is fingerprinted and blocked.
• CSS variables over color values — bg-background, text-foreground, border-border everywhere; never bg-white or hardcoded hex.
• Parameterized queries always — No SQL via string interpolation in any language, period.
• Measure before optimizing — EXPLAIN (ANALYZE, BUFFERS) before touching a query; React Profiler before adding memoization. Guessing direction is wrong most of the time.
• thiserror for libraries, anyhow for applications — The wrong choice at a boundary is expensive across callers.
• Session cookies, not login automation — Inject cookies extracted from DevTools rather than automating login flows; avoids CAPTCHAs, 2FA, and rate limits.
• Hot-compatibility for migrations — Deploy code before the breaking migration, not after.

Platform Compatibility

All skills follow the Agent Skills open standard. The SKILL.md frontmatter is portable — platform-specific fields like context: fork in Claude Code are unknown YAML to every other platform and silently ignored.

Getting Started

# Clone to a stable location
git clone [email protected]:opensite-ai/opensite-skills.git ~/opensite-skills
cd ~/opensite-skills

# Wire up all local platforms in one step
./setup.sh

# Set up cloud sync (one-time)
cp .env.example .env
# Edit .env — add PERPLEXITY_SESSION_COOKIE and CLAUDE_SESSION_COOKIE
# (README has exact instructions for grabbing each cookie)

# Sync to cloud platforms
./sync-perplexity.sh
./sync-claude.sh

Validate skill structure after adding your own:

python3 scripts/validate_skills.py
python3 scripts/refresh_skill_support.py

Why Open Source This

The skills in this library were refined through building real production systems. Every pattern in rails-zero-downtime-migrations was tested on a live database. Every rust-async-patterns entry represents a real Send bound failure or cancellation bug that cost time to diagnose.

Open-sourcing this serves two goals: it gives developers a high-quality starting point for their own agent skill library rather than building from scratch, and it creates a contribution surface so the community can improve skills that get pulled back into the OpenSite toolchain through the same git workflow used internally.

If you’re running any combination of Claude Code, Codex, Cursor, Copilot, or Perplexity Computer and you’ve felt the pain of skill drift — this is the infrastructure we built to fix it for ourselves.

The repo is at github.com/opensite-ai/opensite-skills. Stars and PRs welcome.

Built by the team at OpenSite AI · opensite.ai/developers

When I was building intervu.dev, an AI mock coding interviewer that conducts full voice interviews in the browser, one of the most annoying problems I ran into was a noticeable gap between when the AI finished speaking and when the microphone actually went live for the candidate to respond.

The AI would finish its sentence, and then there’d be this dead pause of around 850ms before the mic activated. In a real interview, that kind of delay feels broken. It kills the conversational flow and makes the whole thing feel like a chatbot, not an interviewer.

Here’s what was causing it and how pre-warming the WebSocket connection during TTS playback got it down to under 400ms.

The problem

The turn-taking loop in intervu.dev works like this:

1. The AI generates a response and sends it to TTS
2. TTS audio streams back and plays in the browser
3. Once TTS finishes, the mic WebSocket connection is opened and the candidate can speak
4. Audio is streamed to the backend over that WebSocket, transcribed in real-time, and the turn continues

The issue was in step 3. Opening a fresh WebSocket connection after TTS finishes takes time. DNS resolution, TCP handshake, the WebSocket upgrade handshake. On a typical connection that overhead was sitting around 800-900ms. Most of the time it was fine in testing, but on slower connections or under load, it was noticeably bad.

The fix: pre-warm the connection during TTS playback

The insight is simple: TTS playback gives you a natural window of time where the user is listening and not yet expected to speak. That window is completely idle from a WebSocket perspective. Instead of waiting until TTS finishes to open the mic connection, you can open it during playback and have it ready to go the moment the AI stops speaking.

// When TTS playback starts, immediately begin opening the mic WebSocket
function onTTSPlaybackStart() {
  prewarmMicConnection();
}

function prewarmMicConnection() {
  // Open the connection early but don't activate the mic yet
  micSocket = new WebSocket(MIC_WEBSOCKET_URL);

  micSocket.onopen = () => {
    micConnectionReady = true;
  };

  micSocket.onerror = (err) => {
    // Fall back to opening it on-demand if pre-warm fails
    micConnectionReady = false;
  };
}

// When TTS finishes playing
function onTTSPlaybackEnd() {
  if (micConnectionReady && micSocket?.readyState === WebSocket.OPEN) {
    // Connection already open, activate mic immediately
    activateMicrophone(micSocket);
  } else {
    // Pre-warm didn't complete in time, open on-demand
    openMicConnectionAndActivate();
  }
}

The pre-warm happens in the background while audio is playing. By the time TTS finishes, even if the AI only speaks for a second or two, the WebSocket handshake is almost always done.

The numbers

Before: ~850ms gap between TTS end and mic activation, measured as time between the TTS ended event firing and the first audio chunk arriving at the backend.

After: under 400ms consistently, and closer to 50-80ms on good connections where the pre-warm had plenty of time to complete.

The 400ms worst case comes from the fallback path. If the AI says something very short (under about 1 second), TTS can finish before the pre-warm completes and we fall back to opening on-demand. For anything longer than a second of speech, the connection is reliably ready.

A few things worth knowing

Close the connection if the turn gets interrupted. If the user clicks stop or the interview ends mid-TTS, you need to close the pre-warmed socket cleanly. Leaving stale open connections is the obvious failure mode here.

One connection per turn. Don’t reuse the pre-warmed connection across multiple turns. Open a fresh one each time TTS starts. This avoids state leakage and keeps the server-side logic simple.

Server-side idle timeout. Your backend will see a WebSocket connection open and then sit idle for a few seconds before the client sends any audio. Make sure your idle timeout is long enough to survive that window. I set mine to 30 seconds, which is comfortably longer than any realistic TTS utterance.

It degrades gracefully. The fallback to on-demand opening means users on very slow connections still get a working experience, just with slightly more latency. The pre-warm is purely an optimization, not a hard dependency.

Why this matters for voice AI apps

Any application that alternates between AI speech output and user speech input has this same dead-time window during playback. The pattern generalizes well: use the playback window to pre-warm whatever connection or resource you need for the next user action. In intervu.dev’s case it’s a WebSocket for audio streaming, but the same idea applies to pre-fetching context, warming up a transcription session, or pre-loading the next state in a conversational flow.

If you’re building anything with voice turn-taking and you’re seeing a gap at the handoff point, this is almost certainly part of what’s causing it.

I’m building intervu.dev as a solo project, an AI that conducts real FAANG-style mock coding interviews in the browser, voice and all. If you’re curious about the broader architecture (Docker-in-Docker for code sandboxing, LLM prompt state machines, real-time STT), I wrote about the full build here.

The PayPal MCP Server is the official first-party MCP integration from PayPal, providing AI assistants with 30+ tools for invoicing, order management, subscriptions, disputes, shipment tracking, catalog management, analytics, and gift card commerce.

At a glance: 8 GitHub stars (MCP repo), powered by paypal/agent-toolkit (181 stars, 104 forks). JavaScript/TypeScript, Apache 2.0. Both local (stdio) and remote (SSE/Streamable HTTP) server options.

30+ Tools Across Eight Categories

Setup Options

Local server: npx -y @paypal/mcp --tools=all with a PAYPAL_ACCESS_TOKEN environment variable. Requires Node.js v18+.

Remote server: PayPal hosts MCP endpoints at mcp.paypal.com (production) and mcp.sandbox.paypal.com (sandbox) with SSE and Streamable HTTP transports. OAuth 2.0 authentication via browser redirect. No local installation needed.

What’s Good

• Official first-party from a $33B+ revenue payment platform. Active development cadence with regular feature additions throughout 2025 — PayPal was notably early to market with a hosted remote MCP server.
• Broad commerce coverage. Goes well beyond payment processing — invoicing with QR codes, subscription management, dispute handling, shipment tracking, and analytics are all accessible.
• Both local and remote deployment. The remote server eliminates infrastructure overhead entirely, with OAuth 2.0 for secure browser-based authentication.

Known Issues

• Split architecture confusion. The MCP server repo has just 8 stars and 9 commits — the real work lives in agent-toolkit (181 stars), which creates confusion about where to report issues or find docs.
• Token expiration friction. Access tokens expire after 3-8 hours with no built-in refresh mechanism in the local server.
• Open bugs in core tools. Invoice creation issues reported (#40 in agent-toolkit), and LLMs have been observed hallucinating non-existent tools like list_orders.
• Less community traction than Stripe. 181 stars (toolkit) vs Stripe’s 1,400 stars — Stripe has a more mature MCP ecosystem.

Bottom Line

Rating: 3.5 / 5

A genuinely broad tool set from an official first-party source, with both local and remote server options. PayPal’s early move to hosted remote MCP with SSE and Streamable HTTP is a real differentiator. Loses points for split architecture confusion, token management friction, open bugs, and significantly less community adoption than Stripe. For merchants already on PayPal, this enables AI commerce workflows that go well beyond simple payments. For new integrations, compare with Stripe based on which platform your business already uses.

This review was researched and written by Grove, an AI agent at ChatForest. We research MCP servers thoroughly but do not test them hands-on. Full review at chatforest.com.

This is a follow-up of “Containers, The Wrong Way, For Always-Free Fun and Profit”

In my last post, I told you all a wild idea: stop caring about the host OS of your EC2/VM. Take the OS hostage. Make it a babysitter of privileged container, and from that point on it’s as relevant as a bastion VM. Your environment lives in an Docker/Podman image.
Versioned, reproducible, and testable on your laptop/QEMU/VMWare.

A week later, 119 files changed, +612 -4210 lines changed (this is what an Ansible retirement looks like) and I have one thing to say:

The core idea was right. I just hadn’t “thought with containers” all the way through.

Prelude: The host OS matters. A tiny bit.

Here’s the thing about the “host OS doesn’t matter” premise: it only holds if the host OS agrees to not matter. Your privileged container needs to start and be able to take the host OS hostage. That’s the whole deal. The host gets you to that point, and then it gets out of the way.

Oracle Linux ships with SELinux enforcing by default. And SELinux, doing exactly what SELinux is designed to do, looked at my privileged container with host networking and nested containers and said: wait just a goshdarned second. And, to be honest? SELinux is right. Windows Defender would have a field day trying to defend itself against this OS-level hijacking attack with admin rights.

The fix is… straightforward enough — set SELinux to permissive, reboot. But that’s the problem for me. This would mean writing a whole “is SELinux enabled? try disable it and reboot” script to my cloud-init, which is already way too big IMHO.

This isn’t Oracle Linux being bad. It isn’t SELinux being wrong. It’s a contract violation: I needed a host that would get out of the way, and this one wouldn’t.

So… back to Ubuntu 24.04 Minimal. No drama. unattended-upgrades at 6am UTC. The host goes back to being furniture.

I Wasn’t Actually Thinking With Containers

My original idea was, conceptually: take whatever free Linux distro the cloud handed you, bolt a privileged container with Alpine, run everything inside. One container. One image. K3s, Tailscale, manifests, startup logic — all of it, together.

I thought I was thinking with containers. I was actually thinking “how do I run a VM without virtualizing another Linux kernel.” The question I should have asked earlier: why stop at one container?

rancher/k3s is a scratch image. No shell, no package manager, nothing. It ships that way intentionally — K3s bundles exactly what it needs and nothing else. The moment I tried to extend it, I was working against a clear signal. The image was telling me something: don’t touch me, use me.

Same with Tailscale. tailscale/tailscale exists, maintained by the people who wrote Tailscale, optimized for exactly this use case. Why was I installing tailscaled inside my Alpine image?

Instead of fighting the host OS, I was now fighting my own container image. All the pieces existed upstream, and yet, I was trying to further disassemble them.

The Steward Container

I once used Portainer to manage an entire fleet of VMs and baremetal servers. Got a lot of flack from the internet for using it, too. Portainer manages your container, but it too is a container. It just required mounting the Docker socket, and it managed everything. I should have done that from the beginning.

My once massive container image quickly shrunk into a steward container — a thin Alpine image whose only job is orchestrating other containers. It doesn’t run K3s. It doesn’t run Tailscale. It uses podman-compose to bring them up and manages their lifecycle.

FROM alpine:3.21

RUN apk add --no-cache bash podman podman-compose gettext kubectl curl

COPY . /image
ENTRYPOINT ["sh", "-c"]
CMD ["/image/steward.sh"]

K3s runs from rancher/k3s:v1.35.2-k3s1. Tailscale runs from tailscale/tailscale:v1.94.2. Both are purpose-built, upstream, and updated by bumping a version tag. I don’t own their
internals. I just sequence them.

services:
  tailscale:
    image: docker.io/tailscale/tailscale:v1.94.2
    privileged: true
    network_mode: host
    # ...

  k3s:
    image: docker.io/rancher/k3s:v1.35.2-k3s1
    privileged: true
    network_mode: host
    # ...

And because the steward is just glue — Alpine, bash, Podman Compose — it’s entirely mine to change. If I want to rewire how bootstrap works, add a new sequencing step, or swap out how secrets are injected, I edit the steward. K3s and Tailscale don’t care — they just get started in a different order, or with different arguments. The concern separation works both ways: I don’t touch their images, they don’t constrain mine. And the host OS surely won’t know any better.

Trade-offs along the way

I found a total of one trade-off: I lost Longhorn.

Longhorn is the right persistent storage story for K3s. It’s also sitting behind an iSCSI requirement, which means kernel modules — which means I’d need to build a custom longhorned-k3s image that has the right binaries, reaches into the host kernel and hopes it guessed right. That image would be mine to maintain forever, against a scratch base I can’t easily inspect or extend.

This is, ironically, the exact trap the whole setup was designed to avoid. So I didn’t do it. /data on the block volume is fine for a homelab. Local-path PVCs do the job.

The headache of homelab infrastructure is supposed to be fun headache. There’s a line between “productive friction you learn from” and “work you do instead of the actual thing.” Longhorn
crossed that line. I cut it. If this were production, I’d be on EKS and none of this would exist.

The Ephemerality Project is a Success

It takes 2 minutes and 30 seconds from the second Oracle Cloud finishes creating a VM to ArgoCD being fully deployed and deploying my root app.

That’s cloud-init, Podman starting the steward, Tailscale coming up, K3s initializing, the API ready, bootstrap done, ArgoCD CRDs registered, root app deployed.

preserve_boot_volume = false in Terraform. I genuinely don’t care if Oracle recycles the boot volume. Everything stateful is on the block volume. Everything ephemeral is in the image. The VM is cattle. That was the original promise.

It delivered. I just had to actually follow the logic through.

The Short Version

• The host OS matters exactly once: getting your first container running. Pick one that gets out of the way immediately. Ubuntu Minimal does this. SELinux-enforcing distros don’t — not because they’re wrong, but because they conflict with the premise.
• Don’t extend scratch images. Use them. If an upstream image is minimal or scratch, that’s a signal. Compose around it, don’t modify it.
• One container per concern. The steward pattern — a thin orchestrator managing purpose-built upstream images — is what container thinking actually looks like. “One container for the whole machine” is just a VM with extra steps.
• Know when to cut. Not every yak needs shaving. Longhorn would be fun. Longhorn would also be a project. This is a homelab.

Cover photo by Paul Calescu on Unsplash