Project Portfolio

Skills are declared as structured contracts — a YAML manifest plus a Markdown prompt — that specify typed inputs and outputs, which per-brand memory files they read, which integrations they require, and whether they write to a live system. Skills chain into multi-step “playbooks” (onboarding, SEO deep-dive, CRO sweep, paid-acquisition audit, and others) that can pause for a client questionnaire and produce review-ready output for the operator to apply, rather than writing to live systems unattended. Output is deliverable-first: a draft-to-final lifecycle, inline editing with live re-render, an “unbrand” white-label toggle, and a report generator that consolidates a date range of completed jobs into a one-page executive summary.

Technical highlights

• Per-job runner spawns the Claude Code CLI as a subprocess, parses its stream-json output into a typed event log (with per-run cost and turn counts), enforces timeouts, and tree-kills orphaned child processes on shutdown.
• Pluggable LLM-provider layer with adapters for Claude, Gemini, OpenAI, DeepSeek, and a local Ollama route, configured from a single providers.yaml consumed by both the TypeScript runner and the Python scripts.
• Live-data integrations over the Model Context Protocol — Google Ads, GA4, Search Console, Sheets, Drive, Ahrefs, and LinkedIn Ads via Composio, plus first-party Python MCP servers.
• Strict per-tenant isolation: every database query is scoped to (client, brand), filesystem paths are validated against traversal, and a “cross-brand read guard” warns if a skill session touches another brand’s files.
• Self-updating “brand memory”: a meta-skill reconciles each strategic run’s findings against six canonical per-brand Markdown files and demotes contradicted claims so each engagement informs the next.
• Deliverable pipeline renders branded PDFs via Puppeteer, exports fillable questionnaire PDFs (pdf-lib) and Word documents (docx), and includes a PSD-to-template editor (psd-tools + Pillow) that turns design files into branded report templates; recurring runs are scheduled in-app with node-cron and catch up on boot.

How it works

Four layers: a Next.js 15 / React 19 dashboard (App Router, routes under /c/[client]/[brand]/… plus roughly 50 API route groups); a catalog of self-contained skills and ten reusable sub-agents; a library layer holding the runner, provider adapters, MCP registry, scheduler, brand-memory hooks, and document renderers; and persistence split between a single SQLite database (jobs, events, schedules, playbook-runs, scans) and a per-brand filesystem tree (context, guidelines, assets, outputs, deliverables, credentials). A “job” is the unit of work, and an “include in scope” flag marks the jobs the report generator may consolidate.

Each site exposes a filterable index of case studies built on a fixed ten-section structure (metadata, summary, timeline, narrative, root-cause analysis, five contributing factors, aftermath, lessons, and references), organized under a per-site Custom Post Type with four taxonomies that drive client-side filter chips. Each thematic family carries its own visual skin over a shared clinical “case-file” system, and sites cross-link through a generated related-index.

Technical highlights

• Two-phase Python content expansion embeds LLM-authored structured prose directly into a per-site entries.json, merged by entry ID.
• Idempotent PHP importer upserts posts by a unique ID meta key and encodes JSON fields with JSON_UNESCAPED_UNICODE to survive WordPress’s slash-stripping.
• Adding a whole new four-site family is a single manifest-driven run rather than bespoke setup — a scaffolder clones the canonical template (CPT slug, prefix, taxonomies, hero copy) via ordered string substitution.
• OG-card pipeline renders a 1200×630 HTML card per entry via Playwright headless Chromium, then uploads PNGs over FTPS with TLS.
• A cross-site related-index script queries each site’s WordPress REST API, normalizes taxonomy tags, and fuzzy-matches titles to live slugs for “see also” recommendations.
• Per-site deploy.sh pushes theme files over explicit FTPS (curl --ssl-reqd) with single-file, multi-file, and full-sync modes.

How it works

Hand-written seed entries per niche are expanded in two Python batch passes into full structured content, uploaded into the theme’s seed directory, and upserted idempotently via an admin-gated importer. The WordPress theme (one per site, generated from a canonical template) registers the Custom Post Type, taxonomies, and meta fields and renders each section in fixed order; the OG-card and related-index scripts run separately against the live sites.

Skills activate automatically when the agent detects a matching intent, then orchestrate API calls, MCP tools, and data synthesis without manual intervention. Integrations are routed through the Composio MCP layer so the skills stay declarative — they specify what to do, not how to authenticate or paginate. A marketing-operations-orchestration skill acts as a dispatcher, routing compound requests across specialist skills in sequence.

Technical highlights

• 15 skill packages across SEO (Ahrefs, GSC, JavaScript-SEO auditing), paid search/analytics (Google Ads, GA4), competitive intelligence, research, scraping, CRO, and outreach.
• API access via MCP (Ahrefs, Google Ads, GA4, Search Console, ScrapingBee) plus Exa neural search and Firecrawl for research synthesis.
• A competitive-ads extractor pulls and analyzes ads from public ad libraries; a deep-research skill returns cited, multi-source reports.
• Structured YAML front-matter (trigger conditions, integration requirements) drives reliable agent dispatch.
• Provenance metadata distinguishes owner-authored skills from curated community/third-party imports.

A generation request is routed to the most appropriate engine, run on a warm GPU worker, and converted to a watertight, multi-body mesh; the result passes through a printability gate before it ever reaches the user. Beyond raw generation, a reusable CAD “skills” library produces parts that are watertight by construction (Gridfinity bins, threads, hinges, heat-set bosses), and a JSON parameter schema backs a slider-driven rebuild path so iteration costs nothing in tokens or GPU time.

Technical highlights

• Orchestrates a Claude Code CAD agent plus five integrated open-source generative engines (TripoSG, Hunyuan3D, PartCrafter, Zero123++, and FLUX.1-dev for image input) into validated, print-ready files — running entirely locally.
• An independent printability validation gate re-checks every generated mesh — watertightness, consistent winding, positive volume, triangle budget, build-plate fit, and connected-body count — so model output is never trusted on self-report.
• Deterministic parametric-rebuild path (a generator script plus a JSON parameter schema) lets users tune and recolor models via sliders with zero LLM or GPU calls, cutting edit latency from minutes to seconds.
• Reusable CAD “skills” library of watertight-by-construction generators, plus a content-safety screen and a cost-aware model router, hardened by a golden-set regression harness that also measures agent honesty.
• Containerized with Docker Compose and a privileged engine-supervisor that swaps warm GPU engines per lane within a fixed VRAM budget, keeping the untrusted prompt-driven app isolated from the Docker control plane.

The upstream pipeline derives animation timing from word-level Whisper.cpp transcripts so motion stays locked to narration. The owner authored four brand-specific video templates that conform to the pipeline’s phase-contract (for defense-industry and higher-ed contexts), and adapted the toolchain for Windows — invoking Claude Code directly and swapping the speech stack to edge-tts + Whisper.cpp — to resolve silent-render and dependency-install failures.

Technical highlights

• Authored four custom HTML/GSAP brand video templates conforming to the pipeline’s phase-contract and timing-anchor protocol.
• Adapted the open-source pipeline for Windows production (direct Claude Code invocation; edge-tts + Whisper.cpp), fixing upstream silent-render and install failure modes.
• Produces narrated 1080×1920 vertical Shorts (~24–30s) end-to-end, from topic prompt through browser preview.

The pipeline runs a fixed sequence: fetch, deduplicate against a seen-articles file, hydrate thin article bodies through a four-tier escalation chain, summarize with a two-prompt strategy, score each article for business-development fit, synthesize a snapshot and an opportunities roundup, and write the briefing. An /authors page aggregates recurring bylines and pre-generates a tailored outreach pitch for each.

Technical highlights

• Four-tier body hydration — direct GET, AMP variant, archive lookup, then Playwright with 19 stealth evasions for JavaScript-heavy or bot-walled sources.
• LLM summarization and scoring run via the Claude Code CLI (no API key); batched JSON-output scoring cuts token usage roughly tenfold versus per-article calls.
• A Wayback “Save Page Now” queue handles paywalled sources — articles are submitted on first failure and the historical briefing is rewritten in place once a snapshot appears.
• Per-author outreach generator drafts a pitch angle, proof anchors, and a ready email, cached by a hash of the author’s flagged articles and the brand-context documents.
• Entirely file-based state with content-hash cache keys, so editing the brand-context document automatically invalidates affected summaries and scores.
• A file-based dual-transport layer switches the pipeline’s LLM calls between a headless subprocess and an interactive Claude Code session, with stale-response detection and an abandonment circuit breaker.
• A thumbs-up/down feedback queue folds committed ratings back into later opportunity-scoring calls; a context-aware ad-hoc prompt box and an Azure Neural TTS voice readout round out the dashboard.
• Launcher sweeps only orphaned LLM worker processes (by checking for dead parent PIDs), preserving live interactive sessions.

The dashboard goes well beyond a reading list: an action queue with deadline-driven urgency coloring, a Q&A page over the briefing corpus with inline citations, an LLM-clustered “recurring themes” page, a tax-year planner that buckets tax-flagged articles across 14 lanes against the IRS deadline calendar, a Networthify-style FI projection with live sliders, a savings-waterfall contribution calculator, and a curated FI glossary.

Technical highlights

• Four-tier article hydration with a Reddit-specific JSON path that captures selftext and top comments, bypassing the single-page-app.
• A 38-pattern refusal detector evicts any summary where the model produced a polite non-answer and re-summarizes on the next run.
• Personalization is driven by a single profile file; the dashboard’s “patterns” page writes committed or excluded strategies back to managed sections of it, and the scorer’s cache key hashes the file so edits auto-invalidate.
• Batched actionability scoring (10 articles per call) tags each item with one of eight action categories (tactic, tax move, allocation, monitor, skip, and others).
• A separate TTS pass spells out numbers and phoneticizes finance acronyms (e.g. “H-S-A”) for a clean spoken readout.
• Snapshot protection: if a re-run yields fewer articles than the existing day’s file, the original is preserved to avoid regressions.

Each run fetches articles published in the prior 24 hours from all sources in parallel, hydrates thin bodies through a four-step escalation chain, summarizes via the Claude CLI, and batch-scores articles against the brand’s “super memory.” The scorer returns structured JSON: an industry-relevance gate, an actionability fit, a tagged recommendation, a geo-weighted relevance score, and an audience route (marketing, executive, or both).

Technical highlights

• Four-step hydration (direct GET → AMP → Wayback archive → Playwright) with a “Save Page Now” fallback queue for stubborn sources.
• Batched LLM scoring (10 articles per call) with strict JSON-schema validation, tag-prefix enforcement, and per-article fallback on failure.
• Geo-weighted relevance — bonus points for active gallery markets and a planned location — keyed to the brand-context document.
• Three-layer local caching (summary, opportunity, range-roundup), each invalidated by content/profile hashes.
• A dual-prompt summarizer adapts to rich vs. thin article bodies, with a refusal-detection safety net.
• Custom Flask “Newsroom Terminal” dashboard (which replaced an earlier Streamlit prototype) with multi-day roundup synthesis, a flash-bulletin marquee, filter chips, glossary tooltips, and a Cloudflare-Tunnel auth gate.

The batch generator filters by role code, groups records by institution (keeping multi-contact institutions atomic so they’re never split across batches), and packs them into ~100-row Apex scripts that resolve accounts, deactivate stale contacts, and upsert each contact as an update, insert, or lead conversion. The campaign script chunks account IDs into batches and enrolls qualifying contacts, falling back to the most-recently-updated matching lead for accounts with role gaps.

Technical highlights

• Greedy bin-packing keeps every contact from one institution in the same batch, preventing partial-institution imports.
• Three integrity assertions run before any file is written — row-count invariant, no institution split across batches, and no duplicate emails — aborting the run on violation.
• Generates Anonymous Apex (not metadata), runnable verbatim in the Salesforce Developer Console without a deployment.
• Partial-success DML (Database.insert(..., false)) so individual record failures don’t roll back a batch; duplicate-member errors are caught for safe re-runs.
• Every run emits an audit manifest mapping each record to its batch file, plus a skipped-rows file.
• Pure standard library plus openpyxl — no heavy dependencies; handles both XLSX and CSV input.

Inside the embedded admin UI (rendered in the Shopify admin iframe via App Bridge), merchants sync metafield definitions through a paginated Admin GraphQL query — no data re-entry, because values live in Shopify. Each definition becomes a spec record (with optional units and value-to-icon mappings); charts snapshot resolved product data into a JSON column for fast reads. On the storefront, a Theme App Extension injects a Liquid block whose bundled JavaScript calls back through the App Proxy, which validates the signed request and scopes the lookup to the requesting shop.

Technical highlights

• Shopify App Proxy secures the public chart-data endpoint: every storefront request’s signature is validated before a shop-scoped lookup, preventing cross-store data leakage.
• Theme App Extension (Liquid + esbuild-bundled JS/CSS) exposes ~10 Theme Editor style settings so merchants can style tables without touching CSS.
• Three-tier billing via Shopify’s native Billing API with server-side limit enforcement (tables and products per plan).
• Webhook deduplication table guards against Shopify’s up-to-48-hour retries; products/update and metafield_definitions/update webhooks keep snapshots and labels in sync.
• Prisma + PostgreSQL with Shopify session storage and refresh-token rotation for expiring offline tokens.
• Admin app built with Polaris; extension assets bundled separately via esbuild, app built with Vite.

The wizard collects household details with accessible card-tap inputs; a “concern type” selector reorders result categories to surface the most relevant items first. Supply tiers at 14, 30, and 100 days change both the recommended product set and the written strategy. Results show per-category metrics alongside filtered product cards, an “add full plan to cart” multi-item Amazon link, a cited deep-dive rationale, and a print stylesheet.

Technical highlights

• Pure-function calculation core (no React, no I/O) makes every formula trivially testable — 27 Vitest tests, all green.
• Three-tier escalation logic gates both product selection and strategy copy per category.
• Full URL-state hydration via query string makes any plan shareable and deep-linkable.
• Four JSON-LD schemas (SoftwareApplication, Product, FAQPage, HowTo) injected for rich-results and AI-overview surfaces.
• GitHub Actions CI/CD: every push to main runs typecheck + tests + static build, then SFTP-deploys in ~2 minutes.
• CSV-driven sourcing script surgically patches product IDs, images, and prices into the typed catalog via regex without disturbing surrounding code.

After a one-time setup flow (auto-discovery or manual IP, then the standard bridge-button pairing handshake), the main view shows rooms and per-light cards with on/off, brightness, and an HSV color picker that includes an eyedropper and image-palette extraction. Scenes can be recalled, created from the current state, or deleted; a Routines tab schedules per-weekday scene recalls; and a “Labs” section adds bridge-side wind-down and wake-up effects.

Technical highlights

• Dual API mode: routes through Hue CLIP v2 on capable bridges and falls back to Hue v1 REST on older hardware.
• Real-time light state via a persistent SSE connection; the Rust backend translates v2 fields into v1-compatible units and emits patch events to the React frontend.
• SSE consumer runs in a Tokio task with exponential-backoff reconnect; a shared atomic flag lets the main thread stop the stream without a mutex.
• Optimistic UI updates roll back by re-fetching from the bridge on failure.
• Process-wide global hotkeys mapped to user-defined quick actions; the system-tray menu is rebuilt on each state refresh to mirror per-room on/off status.
• All communication stays on the local network after pairing — no cloud dependency once configured.

Every file shares a common skeleton — sticky navigation, a full-viewport hero, themed sections, and a call to action — but differs radically in palette, type, density, and interaction model. The more ambitious variants introduce scroll-driven animation, a WebGL2 fragment-shader background, a canvas force-directed graph, and an embedded 3D scene, all without a component framework.

Standout variants & techniques

• Cinematic-kinetic — scroll-linked variable-font animation: heading weight tracks scroll position via a CSS custom property bound to a scroll listener.
• Interactive — the only variant combining a WebGL2 shader background, a canvas network graph, and a Spline 3D scene in one file.
• Scrollytelling — a publication-grade long-form layout driven entirely by IntersectionObserver, with no external scroll library.
• Brutalist — SVG fractal-noise grain via a data-URI background, blend modes, and a radioactive-lime accent — the strongest contrast in the set.
• Zero-Trust SOC — a product-marketing page with a fixed chapter rail using blend-mode navigation that switches to frosted glass on scroll.
• Editorial / Pitch — broadsheet typesetting with OpenType features, and an investor-deck aesthetic on Tailwind via CDN.

Every form submission fires two parallel paths: a client-side fetch() from the visitor’s browser (carrying the Pardot first-party cookie for tracking continuity) and a server-side request as a retrying safety net. Submissions are stored in a custom table, with sweep-based hourly retries that work around Pantheon’s disabled WP-Cron, silent-rejection detection, and admin controls for per-row retry, diagnostic test-push, and one-click lead-data copy.

Technical highlights

• Hybrid client/server Pardot submission architecture for cookie continuity plus delivery reliability.
• Custom MySQL queue table managed via dbDelta with automatic column migrations and a four-state status taxonomy.
• Sweep-based retry system that runs on Pantheon’s external cron and on queue-page load, replacing WordPress’s scheduled-event system.
• Admin tooling: a no-code form/URL mapping screen and a queue manager under Tools, plus rate-limited email alerts on failures.
• “Spectrograph” blog mockup hand-coded with a custom inline-SVG illustration, Bootstrap 5 grid, and a full brand-token system.
• A Node/Puppeteer script captures full-page mockup screenshots for design review (four versioned iterations).

Specialty Trade Contractor

A theme for a licensed drywall contractor. The front page delivers six content blocks including a draggable infinite-scroll testimonial carousel (27 real reviews embedded in PHP), with custom Services and Gallery templates (CDN-served photos), a CSS-only mobile nav, and an American-flag logo mark drawn entirely from CSS pseudo-elements.

DKB Media

A dark-mode agency theme for DKB Media’s own site. Highlights include a Canvas-API animated node-graph hero, rotating headline words, animated stat counters, a CSS-particle workflow diagram, a custom nav walker, and a Customizer panel for editable contact info. A deploy.sh script uploads changed files to shared hosting over FTPS with credentials kept outside the project.

SimplyCompare

A light-mode marketing/landing theme for the SimplyCompare Shopify app, featuring a live HTML table demo in the hero, a CSS-only pricing grid, a FAQ accordion, and a privacy-policy template. Two versioned ZIP update packages show a manual re-upload workflow alongside the scripted one.

Common approach

• All three are classic PHP themes (no block/FSE), rendering full markup through get_header/get_footer and named page templates.
• Mobile navigation solved differently per site (CSS-only checkbox, JS burger, hidden links) to match each site’s complexity.
• Interactive components — carousel, lightbox, canvas animation — written without library dependencies.
• CSS design tokens for color, type, spacing, and shadow across all three; no preprocessor or build step.
• Deployment by FTPS script (DKB Media) or theme-ZIP upload through the WordPress admin.

Because shared hosting offers no SSH or WP-CLI, the toolkit executes WordPress operations through a self-deleting PHP mu-plugin dropped over FTPS and triggered by HTTP — handling theme activation, content seeding, DB migration, and URL rewriting. Each operation is token-gated and backed up so it can roll back, and the manifest carries the per-site metadata that parameterizes provisioning, migration, and seeding.

Technical highlights

• End-to-end WordPress site provisioning via cPanel UAPI, Softaculous, and FTPS — idempotent, step-resumable, and with zero third-party Python dependencies (stdlib only).
• Self-deleting PHP mu-plugin pattern executes WordPress operations over HTTP on shared hosting with no SSH or WP-CLI access.
• Automated live relocation of 72 sites from subdomain to path-based URLs — patching wp-config.php, serialized DB data, theme files, and .htaccess in a token-gated transaction with rollback, verified by a 2,824-URL internal crawl returning all HTTP 200.
• Three-phase single-install-to-multisite conversion that respects WordPress’s load-order constraints, with full file backup and rollback.
• Manifest-driven fleet: a single JSON manifest (73 site rows) carries per-site metadata controlling all provisioning, migration, and seeding operations.

The content script scans the DOM for export download links, populates a fixed panel with a start-from picker (to resume mid-batch), and clicks each link in sequence with a live progress bar and countdown. Session state is persisted so a mid-run page reload auto-resumes; pause/resume freezes the countdown and stop resets everything.

Technical highlights

• Content script injected into all frames to handle both the top-level Classic page and the Lightning iframe.
• Rate-limit compliance baked in via a hardcoded 75-second interval between native anchor clicks.
• Session-storage resume survives page reloads mid-batch without losing queue position.
• No background service worker and no downloads API — downloads are delegated to the browser via simulated anchor clicks.
• Self-contained injected UI with minimize/expand, an activity log, and start/pause/stop controls.