Courses

Animated single-file HTML deck, exportable to PDF or converted from PPT

Multi-sheet .xlsx with live formulas, charts and pivots

.docx with tracked changes / redlining, or long-form Markdown

A natively editable .pptx — every text box, shape and chart is a real PowerPoint object, clickable and editable in PowerPoint, Keynote or WPS. Not images packed into slides.

Plug an agent into your existing Word / Excel / PowerPoint folder — mail-merge, formula recompute, structured table extraction and HTML review — all local, no Office install, no cloud.

A Nature-style submission bundle — redlined .docx manuscript, vector figure (SVG/PNG), defense .pptx and a point-by-point peer-review response letter, with citations auto-pulled from PubMed / CrossRef / arXiv.

Paste an arxiv URL and get back a runnable Python repo — every block of code carries a §section / Eq.N anchor; unspecified hyperparameters are flagged inline, with an ambiguity audit and a walkthrough notebook alongside.

High-res image sets (covers, OG images, illustrations)

You'll walk away with your own branded DESIGN.md, and you'll be able to ask any mainstream coding agent to generate two structurally different but visually on-brand pages (landing + detail) in a single session — colors, typography, radii, and button styles unmistakably belonging to the same brand.

Write architecture, sequence, and ER diagrams as plain text, render them locally to versionable SVG/PNG, and export an editable .excalidraw of the architecture flow.

One dataset and one sentence produce a publication-grade chart pack: a high-res PNG you can drop into a README / deck / report, a vector SVG, and a reusable Vega-Lite / ECharts / Chart.js spec you can embed in any web app. Swap the palette or the dataset in one line and the chart re-renders.

One command lets your coding agent read an existing web app, ship a human-readable test plan, translate it into runnable Playwright specs, drive them into a trace-backed HTML report, and self-heal broken selectors when the UI drifts.

Describe a concept, formula, or algorithm in a few lines of Python and render it locally into a 3Blue1Brown-style, step-by-step explainer animation .mp4 (1080p) — ready to post anywhere.

3-5 captioned vertical .mp4 clips with a unified cover

Multi-source montage .mp4 with BGM ducking, B-roll, burned subs

Studio-grade 44.1 kHz mono .wav voiceover (31 languages, inline <laugh>/<breath> tags)

A PDF or long article becomes a 12-minute two-host MP3 podcast with a speaker/timing dialogue script and a 1:1 cover — all generated on your machine, files yours to publish

One text prompt → a complete original song or BGM generated locally (melody, harmony, arrangement, optional vocals & lyrics), exported as a royalty-free 48 kHz .wav you own

Write a <MyVideo> component in React + TypeScript and render it locally with Remotion + ffmpeg into a real 1080p / 30fps .mp4 — swap props to change brand, data, or copy, generate dozens of variants from one codebase, ready for socials, product pages, and internal updates.

1-10 panel cartoon-style grid + copy + tags

Write one responsive HTML email with semantic tags that renders cleanly in Gmail, Outlook, and Apple Mail; compile it locally to a send-ready .html, with real desktop + mobile render previews.

Rewrite an AI-drafted marketing email, RED post, or internal comms so it reads like a person wrote it — with a real before/after report scored by two public AI detectors.

Message, docs, sheets, base, calendar, mail — all inside Lark

A working SKILL.md pack you can install in Claude Code, trigger on the right prompt, and publish to GitHub as a portfolio piece

Print-grade typeset PDF — conference papers, research posters and finely set booklets, with LaTeX-quality typography from reproducible plain-text markup

Turn messy PDFs, scans, papers, contracts and Office files into clean Markdown and structured JSON — LaTeX math preserved, tables rebuilt, figures extracted — ready for notes, RAG, or further editing.

Turn a real-world pile of .docx / .xlsx / .pptx / .epub / .html / .zip / simple .pdf files into clean, repo-checkable, RAG-ready Markdown in one command — batch in, batch out, one .md per input file. Fully local and free.

Add an invisible OCR text layer to scanned / photographed / image-only PDFs — the original layout stays exactly the same, but the file is now Cmd-F searchable, copy-pasteable, and indexable by Spotlight and full-text engines. Fully local, offline, free.

Translate an English PDF into a bilingual PDF that keeps the original layout (English on one page, same-layout Chinese on the next) plus a Chinese-only variant — figures, tables and math stay put, columns stay aligned, both files Cmd-F-searchable in Chinese. Default engine is a local Ollama backend; zero commercial API key.

Treat a 5 GB / 50 GB CSV / Parquet / JSON / Excel file as a database and query it directly — datasets that crash Excel or OOM pandas finish in seconds on DuckDB, running on your laptop. One SQL line gets you a result table, one more `COPY ... TO 'out.parquet'` writes a columnar export, a few more lines draw a matplotlib / Plotly chart. Fully local, offline, free.

A shareable HTML security report (overall score + S/A/B/F grade + six risk dimensions + fixes), plus a live local guard that blocks dangerous commands and credential theft on your AI agent. Before installing any third-party skill / plugin / MCP, statically scan it with 24 rules for backdoors, secret theft, exfiltration and Web3 wallet drains.

Remove any image's background locally in one command — get a transparent PNG, a clean white-background product shot, and swap the subject onto a solid / gradient / brand background. Free, fully local.

Split any song into stems locally in one command — karaoke instrumental, isolated acapella vocals, drums / bass / other — exported as downloadable .wav for covers, remixing, sampling and BGM removal. Free, fully local, MIT-licensed commercial-safe model.

Turn any piece of audio or video (mp3 / wav / m4a / mp4 / mov or a yt-dlp link) into downloadable .srt + .vtt captions, a bilingual transcript.html, and optionally a burned-in .mp4 — local faster-whisper transcription + argostranslate offline translation + ffmpeg burn-in, free and fully offline.

Turn a 30–120 min lecture / conference talk / online course link into an Obsidian / Notion-ready lecture-notes.md with timestamped anchors and embedded keyframe screenshots, plus a printable lecture-notes.pdf, a structured key-terms.json glossary, and an interactive outline-board.html where every chapter seeks the video to the exact second.

One command turns your repo into a 100% local SQLite symbol graph wired into Claude Code / Cursor / Codex over MCP. Finding entry points, callers, and impact collapses from grepping 20 files to one tool call — and you walk away with a shareable before/after report where tool calls, context tokens, and turn time all drop measurably.

Run `crv <video>` once and get an agent-ready folder — de-duplicated scene keyframes, a plain-text `MANIFEST.txt` index, and a full `transcript.txt` — that any LLM or coding agent can read to discuss the video without re-uploading the source. Add `--kb ~/Obsidian/...` to also drop a dated markdown note into your knowledge-base folder alongside your existing notes.

Write your first MCP server with the official @modelcontextprotocol/sdk, plug it into Claude Desktop / Claude Code / Cursor / Cline / Windsurf, and watch the AI assistant call into your own tools, scripts, or local data — your code, one JSON config block, one real tool call.

In five minutes, run open chat models like Qwen / DeepSeek / Gemma / Llama on your own laptop, and turn a folder of private notes / PDFs into a fully offline “private RAG assistant” backed by SQLite + nomic-embed — documents never leave your machine, no API keys, no cloud calls.

Turn a domain, a sitemap, or up to 50 web URLs per batch into an indexed, full-text-searchable Markdown knowledge base — one `.md` per page with frontmatter, plus a self-contained static reader (left-rail TOC, body, top-bar search) you open in any browser. Ready to feed an agent's context, build a RAG, or draft topic posts. Browser rendering happens server-side; locally you only need Node ≥ 18 and one SDK call.

Turn any casual selfie into spec-compliant ID photos in one line — auto-matting + background swap + official sizing (China 1-inch / 2-inch, US visa 2×2, passport, etc.) + a ready-to-print 6-inch layout sheet. Powered by Clawvard SDK, zero third-party keys.

Sweep a messy folder of mixed-format files (PPT, Excel, Word, PDF, images, audio, ZIPs, emails) into a RAG-ready Markdown corpus in one command — one .md per source file with provenance frontmatter, a merged corpus.md, a browsable index.html preview, and a packaged corpus.zip. Fully local, zero commercial API key, zero cloud.

Turn a PDF textbook or Markdown notes into an .apkg Anki deck — front/back Q/A, optional cloze, chapter-level tags, subdeck per topic. Imports cleanly into Anki Desktop, AnkiDroid, AnkiWeb.

Drop a folder of mixed customer data (TXT / CSV / PDF / images) and get back a redacted/ folder with identical layout — names, emails, phones, ID numbers, credit cards and addresses replaced with stable placeholders, plus a side-by-side diff.html and an auditable report.json. Fully local, zero LLM, zero external key. The compliance gate to run before feeding AI, outsourcing, or sharing with research partners.

Compress the tool outputs, logs, grep dumps, long docs, and RAG chunks you're about to feed your agent by 60–95% before they ever reach the LLM, and ship a single-file `headroom-savings.html` before/after report — tokens before / tokens after / % saved / estimated $ saved at current input prices (formula printed in the report) / side-by-side excerpts / anchors back to the original chunk. After one pip install + one HF public-model warmup, every compress runs locally — zero commercial API key, zero remote LLM, zero vendor lock-in.

Give your coding agent a real browser — log in, click, fill forms, scroll, scrape across pages. One natural-language task produces a step-by-step run.json, one Chromium screenshot per step, and the final extracted JSON / downloaded files.

Two locally produced studio-grade voice assets — a brand-new character voice designed from one natural-language prompt and a cloned voice built from a 10-second reference clip — exported as 48 kHz .wav with 30-language and emotion/speed control, fully offline and free.

Upscale one image or a whole folder of blurry, low-res, over-compressed photos to a crisp 2x / 4x locally — product shots, scanned old photos and social-media screenshots alike — ready to drop straight into a product page, social post, print job or client deliverable. Free, fully local, runs on CPU.

Erase watermarks, photobombers, old logos or burned-in subtitles from any image locally with one brush stroke — the subject stays, the background texture fills back in. Ship a clean output, a reusable binary mask and a clear before/after; batch-erase a full video the same way. Free, fully local, offline.

Point your coding agent at any public URL — it drives a real local Chrome, runs Lighthouse, captures a performance trace and the full network HAR, and ships a one-page audit with screenshots and a plain-English verdict.

Hand your agent one topic — a keyword, a brand, an OSS project — and it sweeps the open web through zero-key channels in parallel, landing a section-per-channel Markdown digest plus a single shareable HTML preview, with title, summary, source URL, platform badge, and fetched-at timestamp on every entry.

Add cross-session, cross-process long-term memory to your AI agent — preferences and facts the user mentioned in past sessions are auto-recalled and injected into the next prompt, strictly scoped by user_id, persisted to a local Chroma + SQLite store, surviving any process restart. The whole stack only talks to 本地 Ollama 端口 — no commercial API keys, no cloud.

Drop a UI screenshot or Figma export to your coding agent — it writes a single-file HTML + Tailwind page that pixel-aligns to the source, renders the same HTML in a real local Chromium at the same viewport, captures a replica screenshot, and lands a side-by-side before-after pair plus a ready-to-open index.html.

Turn any local source-code project into a ready-to-file China NCAC software-copyright application pack — 4 spec-compliant .docx files (user manual + first-30 / last-30 pages of source) plus a pre-filled application-form.txt, ready to print or upload, saving 500–2000 RMB in agency fees.

Hand any Git diff (workspace, branch range, a single commit, or a public PR) to `ocr` — it runs Alibaba's battle-tested AI code-review agent locally, deterministically bundles files into per-file sub-agents, and lands a Markdown report with line-anchored comments plus the same facts as machine-readable JSON, ready to paste into a PR review or pipe into CI.

Upload an NDA, vendor MSA, or DPA and your agent returns a GREEN/YELLOW/RED triage report plus a clause-level redline memo flagging every deviation from your playbook — downloadable as .md and .docx, so the 'first pass' lands in under thirty minutes.

Turn the markdown draft, product copy or CSV you already have into three platform-ready outputs in one local pass on your own machine: a magazine-style article you can paste into WeChat, a 1080×1440 cover card PNG you can ship to Xiaohongshu, and a data report you can drop into newsletter / weekly groups — all driven by the coding agent you are already logged in to.

Turn any Markdown draft into paste-ready WeChat article HTML — pick from six curated themes (moyu-green / red-white / graphite-minimal / zen-whitespace / moyu-ticket / olive-journal) or spin up a bespoke one from your brand palette. Paste into the WeChat editor and styles stay intact, punctuation auto-normalizes, chapter numbers and keyword underlines land automatically.

Turn any video into two artifacts in one local pass: an annotated .mp4 with bounding boxes / trails / counters drawn over people, vehicles or objects, plus a structured analysis.json (zone counts / trajectories / dwell time / speed). No paid API key — model weights download locally on first run.

Turn one sentence or one SVG into a set of production-grade Lottie vector animations — loader, brand entrance, button success, logo reveal — that your IDE agent writes locally and that drop into Web / React Native / iOS / Android / Flutter with one line of code, rendering crisp at any resolution.

Turn any static logo image into a motion-ready vector — a clean SVG, a self-contained interactive HTML demo with replay & slow-motion controls, plus a shareable GIF/MP4 preview — your brand logo coming to life in one prompt.

Sweep your machine's local Claude Code / Codex / Cursor / OpenCode and 25+ other AI-coding session files, and ship a one-month cost report with a daily bar chart, model side-by-side, the five most expensive sessions, and a paste-ready waste-cleanup list — exported as JSON, CSV, and a single shareable HTML page for the boss.

A production-ready loop scaffold checked into your repo — STATE.md, LOOP.md, gate.yaml, loop-budget.md, loop-run-log.md — plus a Loop Ready badge that climbs from L0 10/100 to L3 100/100, a token budget estimate, and a paste-ready audit checklist that turns "I keep hand-prompting" into "I own a scored, hardened loop."

One command sweeps your endpoint's npm / PyPI / Go / RubyGems / Composer / MCP / editor-extension manifests into an inventory.json plus a self-contained HTML risk dashboard — severity pills, hit list grouped by ecosystem, source lockfiles, advisory links, and recommended fixes (pin / remove / replace / rotate-token / restart-agent). Add an optional Clawvard remediation playbook on top. Fully read-only — no installs, no network, no third-party API key required.

Put your coding agent in senior-advisor mode: run a read-only audit on any repo, get findings ordered by impact ÷ effort, then turn the top picks into self-contained `plans/NNN-*.md` specs (with `file:line` evidence, ordered steps, per-step verification commands, STOP conditions, and a `git rev-parse --short HEAD` stamp). When you want to land one, dispatch a cheaper executor in an isolated git worktree and the advisor reviews the diff like a tech lead — approve / revise / block. The advisor never edits source code itself; `execute` writes only inside the worktree, never merges, never pushes, never commits to your branch.

You'll herd four coding agents on the same issue in one terminal, watch a live sidebar mark each as working / blocked / idle in real time, and walk away with a four-branch diff report so you can merge the fastest, cleanest one.

Hand over any listed company (A-share / HK / US) and four background agents research it in parallel through Duan Yongping (business essence), Buffett (moat & valuation), Munger (inversion & bias), and Li Lu (ten-year certainty), cross-challenge each other, verify every market-cap / PE / ROE / valuation number with an exact-decimal Python engine (no LLM guesswork), then pass through a 15% random-sample audit gate — you get one deep-dive report with four-lens scoring, Bull vs Bear, a buy-in checklist, and layered aggressive / balanced / conservative recommendations.

Pick any unfamiliar technical topic (WebGPU compute shaders, Erlang OTP, Bevy ECS) and your coding agent writes a real 3-part hands-on tutorial — runnable code, predict/recall teaching beats, exercises, and cited sources included — saved locally to `~/.lathe/tutorials/` under a per-tutorial folder (for example `webgpu-compute-shader-101`) and read in your browser via `lathe serve`. The LLM lays the path; you walk it.

One command turns any commit range into four release notes — user-facing × team-facing × zh / en — plus a paste-ready GitHub Release body (Highlights, Fixes, Internals, Contributors, and a real Full Changelog link). Every release cycle's busywork collapses into a single SDK call.

Say one line to the coding agent you're already logged in to (Claude Code / Cursor / Codex) — "make me a XX screen" — and it produces self-contained HTML under `designs/<project>/` you can double-click open in your browser: landing pages, admin dashboards, clickable iOS prototypes, and mid-fi wireframes. Iterate by pointing at elements in the live preview.

Run a real AI pen-test on a web app you own. The agent recons endpoints, fires payloads, verifies each PoC, and hands you an OWASP-style report with CVSS scores, a replayable PoC per finding, and an auto-generated remediation patch PR — all against apps you own or are authorised to test.

Run a white-box security audit on a codebase you own and get a drop-in SDL appendix: an architecture map, a severity-ranked report, per-finding data flows with reproducible payloads, and a schema-validated machine-readable findings.json. Only exploitable findings, each with a file:line reference and a real attack scenario; repeat runs on the same repo skip prior findings and target the gaps.

Turn one of your own Linux hosts into an AI app-builder backend: give every prompt its own isolated sandbox, let a coding agent inside write the code, and get a shareable live preview URL in seconds — sandboxes sleep when idle and wake instantly on the next hit.

A real capture of your own MCP session — every handshake, tools/list and tools/call round-trip (including SLOW markers and progress notifications) sitting in your terminal, browsable, filterable, and replayable — plus a "what my MCP is actually doing wrong" diagnostic markdown you can hand to a teammate.

Give your coding agent a lazy-coder guardrail: `/ponytail-review` inspects the current diff before you push and hands back a delete-list of dead paths, redundant abstractions, and reinvented utilities; `/ponytail-audit` sweeps the whole repo through the same lens so old over-engineering finally has to answer for itself; `/ponytail-debt` harvests every `ponytail:` shortcut comment you've scattered around into a single markdown ledger, so "we'll fix it later" no longer means "never."

Send a hand-written SKILL.md through the rollout → reflect → aggregate → select → update → validate loop and walk away with a validation-gated best_skill.md plus a before/after score report you can drop straight into a PR or weekly.

Turn a public URL into a hand-off-ready trio: an A4 print-ready SEO audit PDF, a severity-ranked action plan, and a drop-in Schema.org JSON-LD patch for your <head> — covering technical SEO, E-E-A-T content quality, and AI-search (AI Overviews / Perplexity / ChatGPT) readiness.

Hand your raw-footage folder to an agent, chat about the story you want, and get back a 15–60 s .mp4 with dead space cut, fillers removed, subtitles burned on and a consistent grade — 9:16 vertical reel, 1:1 square ad, or 16:9 meeting highlights.

Give me a Chinese long-form article and I'll produce a set of six style-locked 16:9 hand-drawn inline illustrations — pure-white background, thin black ink lines, sparse red/orange/blue hand-written Chinese annotations, all starring the same black character "Xiaohei". They look like one person drew all six in one sitting and drop straight between paragraphs on WeChat / Zhihu / Notion.

Say one line to the coding agent you're already logged in to — "build me an XX page with Astryx" — and it connects to the official Astryx MCP, scaffolds a Vite React app, installs `@astryxdesign/core` plus a theme, composes six sections (Hero / Feature Grid / Pricing / Testimonial / FAQ / Footer) from the 150+ official components, themes it with a branded `defineTheme` layer, and hands back a `dist/index.html` ready to deploy or drop into your Next.js.

Say one line to your already-logged-in coding agent — "turn on agent-taste-frontend and build me an XX landing" — and it opens with a one-line design read plus three suggested dials (DESIGN_VARIANCE / MOTION_INTENSITY / VISUAL_DENSITY). Confirm the dials and it drops four self-contained HTML files into `taste-out/<project>/`: `before.html` with the taste layer off (agent default), `after.html` with the layer on, two style variants dialed differently, and a `showcase.html` that puts them side by side. Same brief, taste layer off vs. on — the gap is obvious at a glance.

Turn your coding CLI into a job-search command center: paste any job URL and get a six-block fit report (with a scam / ghost-listing check), an ATS-optimized tailored CV PDF, a research-backed cover letter PDF, an interview story bank, and a ready-to-send first email — all tracked in one pipeline table. Anything under 4/5 is flagged as "probably not worth your time" by default. This is a filter, not a spray-and-pray tool.

A live Claude Managed Agent running in your own Anthropic Console plus a ./my-agent/ project folder — build sheet, resumable launch script, eval scaffold, live overview page, and a numbered v1/v2 plan for what ships next — with an optional scheduled deployment when the job recurs.

Run one open-source actions gateway on your machine, wire your GitHub / Notion / Slack / Airtable / Gmail credentials in once, and let Claude Code / Codex / Cursor drive those apps directly — label issues, write comments, open PRs, insert database rows — with every call in an inspectable audit trail and provider secrets pinned to your machine.

Turn one Claude Code / Codex session into a 3D night map of your repo — seen files glow moss-green, read files moon-white, edited files warm-amber — with a 30-second playback clip that shows an agent's path at a glance.

Install a runtime redline guard for any AI coding agent (Claude Code / Codex CLI / Gemini CLI / Copilot CLI / Cursor / Hermes / Grok / Antigravity). When it tries to run rm -rf, git reset --hard, DROP TABLE, kubectl delete namespace prod, aws ec2 terminate-instances, or docker system prune -a --volumes, dcg intercepts before execution, hands the agent a safer alternative, and the agent replans automatically. Five-minute install across all three of your agents.

Say one line to the coding agent you're already logged in to — "use beautify-github-readme to redesign this repository's homepage" — and it reads what actually exists in your project first (README, code, examples, screenshots), pulls out the value and proof worth showing, then chooses a project-native visual direction. You get a hero SVG built from your project (not a template), a small set of section-transition SVGs, a locally rendered README preview, and a reviewable README diff. When someone lands on the repo, the first screen actually tells them what you built.

Say what you want to demo — a repo's first-successful-action, a CLI's how-to, or a real call inside your Agent Skill — and your coding agent drafts a .tape script and renders it locally with charmbracelet/vhs into a ~15-second looping terminal WebM / GIF (1200×750). Paste it straight into a GitHub README hero, an npm-package first look, a Skill landing, or an X thread.

A full AI-slop audit of your vibe-coded landing page: 33 machine tells (indigo→violet gradients, glowing cards, gradient-clip headlines, ALL-CAPS stat trios, kickers on every heading, mascot pileups, "not just X — it's Y" copy…) each pinned to source lines, with an applyable clean diff plus before/after screenshots so the page reads human-made, not machine-assembled.