GitHub JavaScript Daily Trending

Anil-matcha/Open-Generative-AI

Open-source alternative to AI video platforms — Free AI image & video generation studio with 200+ models (Flux, Midjourney, Kling, Sora, Veo). No content filters. Self-hosted, MIT licensed.

Open Generative AI — Open-Source Alternative to AI Video Platforms

The free, open-source alternative to AI Video Platforms. Generate AI images and videos using 200+ state-of-the-art models — no content filters, no closed ecosystem, no subscription fees.

Community: Join Reddit & Discord for discussions and support

🤖 Automate media generations with AI coding agents: Generative-Media-Skills — a library of skills that let agents like Claude Code, Codex, and other coding assistants drive 200+ image/video models end-to-end (prompt → generate → edit → stitch) directly from your terminal. Perfect for building automated media pipelines without touching a UI.

Related projects

Open-source Node based workflow builder -> https://github.com/SamurAIGPT/Vibe-Workflow

Open-source AI Clipping — turn any long-form YouTube video into viral-ready vertical shorts -> https://github.com/SamurAIGPT/AI-Youtube-Shorts-Generator

Open-source AI Design Agent -> https://github.com/Anil-matcha/Open-AI-Design-Agent

🌐 Try it Online — No Install Required

Hosted version: https://muapi.ai/open-generative-ai

Use all four studios (Image, Video, Lip Sync, Cinema) directly in your browser — no Node.js, no setup. Sign up for a free account to start generating. The hosted version is always up to date with the latest models.

Follow the creator for updates

⬇️ Download Desktop App

One-click installers — no Node.js or terminal required.

Platform	Download
macOS Apple Silicon (M1/M2/M3/M4)	Open Generative AI-1.0.9-arm64.dmg
macOS Intel (x64)	Open Generative AI-1.0.9.dmg
Windows (x64)	Open Generative AI Setup 1.0.9.exe
Linux (Ubuntu x64)	v1.0.9 release (`.AppImage` / `.deb`), or build locally with `npm run electron:build:linux`.

All releases: github.com/Anil-matcha/Open-Generative-AI/releases

macOS Installation Guide

Because the app is not notarized by Apple, macOS Gatekeeper will block it on first launch. Follow these steps:

Step 1 — Mount the DMG and drag the app to /Applications

Step 2 — Open Terminal and run:

xattr -cr "/Applications/Open Generative AI.app"

Step 3 — Right-click the app in /Applications → click Open → click Open again on the dialog

You only need to do this once. After that, the app opens normally.

Alternative (no Terminal):

Try to open the app — macOS will block it
Go to System Settings → Privacy & Security
Scroll down to find "Open Generative AI was blocked"
Click Open Anyway → Open

Windows Installation — SmartScreen warning fix

Windows SmartScreen may show a warning because the installer is not code-signed:

Click More info on the SmartScreen dialog
Click Run anyway

The app will install silently to %LocalAppData% with a Start Menu shortcut.

Ubuntu / Linux Installation

Linux artifacts are available when building with Electron Builder:

# Build Linux installers (AppImage + .deb)
npm run electron:build:linux

Generated files are written to the release/ folder:

AppImage — portable, run directly after making executable:

chmod +x "release/Open Generative AI-*.AppImage"
./release/Open\ Generative\ AI-*.AppImage

.deb — install on Debian/Ubuntu:

sudo apt install ./release/open-generative-ai_*_amd64.deb

If AppImage fails to start on older systems, install libfuse2:

sudo apt install libfuse2

Ubuntu 24.04+ / AppArmor sandbox restriction

Ubuntu 24.04 and later enable a kernel security policy (apparmor_restrict_unprivileged_userns) that blocks Chromium's user-namespace sandbox. If the app fails to start silently or crashes immediately, you have two options:

Option A — Recommended: install the .deb instead. The .deb package ships an AppArmor profile that grants the required permission automatically on install with no system-wide changes.

Option B — Temporary system fix (AppImage users):

sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0

This lasts until next reboot. To make it permanent:

echo 'kernel.apparmor_restrict_unprivileged_userns=0' | sudo tee /etc/sysctl.d/99-userns.conf

Open Generative AI is a free, open-source AI image, video, cinema, and lip sync studio that brings creative workflows to everyone. No content filters, no prompt rejections, no guardrails — just full creative freedom. Powered by Muapi.ai, it supports text-to-image, image-to-image, text-to-video, image-to-video, and audio-driven lip sync generation across models like Flux, Nano Banana, Midjourney, Kling, Sora, Veo, Seedream, Infinite Talk, LTX Lipsync, Wan 2.2, and more — all from a sleek, modern interface you can self-host and customize.

Why Open Generative AI instead of other AI Video Platforms?

No filters — no content filters, no nanny guardrails, no prompt rejections
Free & open-source — no subscription, no vendor lock-in
Self-hosted — your data stays on your machine, full creative control
200+ models — text-to-image, image-to-image, text-to-video, image-to-video, lip sync
Multi-image input — feed up to 14 reference images into compatible models
Lip Sync Studio — animate portraits or sync lips to any audio with 9 dedicated models
Extensible — add your own models, modify the UI, build on top of it

For a deep dive into the technical architecture and the philosophy behind the "Infinite Budget" cinema workflow, see our comprehensive guide and roadmap.

⚡ Local Model Inference (Desktop App Only)

The desktop app supports two independent local engines. Pick whichever fits the machine you actually run on:

Engine	What it is	Best for
sd.cpp (bundled)	C++ engine from stable-diffusion.cpp, runs on the same machine as the app. Metal GPU on Apple Silicon, CUDA/Vulkan/ROCm on Linux/Windows.	Image-only models. Works on Mac M-series.
Wan2GP (BYO server)	HTTP client to a user-run Wan2GP server. The server runs Python + PyTorch on a CUDA/ROCm GPU; the desktop app only sends prompts and receives results.	Video models (Wan 2.2, Hunyuan, LTX) and large image models (Flux, Qwen-Image). NVIDIA/AMD GPU required on the server; the desktop app itself can run on a Mac.

Both engines share the same UI: open Settings → Local Models to configure each.

Engine 1 — sd.cpp (bundled)

Model	Type	Size	Notes
Z-Image Turbo ⚡	Diffusion Transformer	2.5 GB + 2.7 GB aux	8-step turbo. Heavy on memory.
Z-Image Base ⚡	Diffusion Transformer	3.5 GB + 2.7 GB aux	50-step high-quality. Heavy on memory.
Dreamshaper 8	SD 1.5	2.1 GB	20-step versatile. Lightest tested option on Mac.
Realistic Vision v5.1	SD 1.5	2.1 GB	25-step photorealistic
Anything v5	SD 1.5	2.1 GB	20-step anime/illustration
SDXL Base 1.0	SDXL	6.9 GB	30-step high-res

Z-Image models require two shared auxiliary files (downloaded once, shared across both models):

Qwen3-4B Text Encoder — 2.4 GB

FLUX VAE — 335 MB

How to use:

Open Settings → Local Models in the desktop app
Install the sd.cpp inference engine (one click — auto-downloaded)
Download your chosen model (and auxiliary files for Z-Image)
In Image Studio, click the ⚡ Local toggle next to the model selector
Select your local model and generate — no API key needed

All downloads happen inside the app. Nothing is installed system-wide.

Engine 2 — Wan2GP (remote Gradio server)

The app does not bundle Python or model weights for Wan2GP. You run Wan2GP yourself on a machine with a CUDA or ROCm GPU and point the desktop app at its URL.

# On your GPU machine
git clone https://github.com/deepbeepmeep/Wan2GP
cd Wan2GP
./install.sh                          # or install.bat on Windows
python wgp.py --listen --server-name 0.0.0.0   # binds to all interfaces

Then in the desktop app: Settings → Local Models → Wan2GP server, paste the URL (e.g. http://192.168.1.42:7860), click Test, then Save. The Wan2GP models become available — image models in Image Studio, video models reachable via the same generation API (Image Studio rejects video output explicitly; full Video Studio wiring is on the roadmap).

Model	Type	Notes
Flux.1 Dev	Image	1024px, 28 steps
Qwen Image	Image	1024px, 30 steps
Wan 2.2 (T2V / I2V)	Video	Slow on consumer GPUs
Hunyuan Video	Video	High-quality T2V
LTX Video	Video	Fastest video option

Why a separate server? Wan2GP's runtime (Sage attention, flash-attn, AWQ/GGUF kernels) is CUDA-only — there is no MPS / Apple Silicon path. Treating it as a remote server lets a Mac-only user keep the desktop app while offloading inference to a Linux/Windows GPU box, a gaming PC on the LAN, or a rented RunPod/vast.ai instance.

Local inference is only available in the desktop app. The hosted web version always uses cloud APIs.

Hardware Notes

sd.cpp runs on CPU (all platforms) and Metal GPU on Apple Silicon (M1/M2/M3/M4); CUDA/Vulkan/ROCm on Linux/Windows.
Metal GPU acceleration is built into the macOS desktop binary — significantly faster than CPU-only.
Recommended for sd.cpp Z-Image: 16 GB RAM (7.4 GB weights + 2.4 GB compute buffer). On a base 8 GB M-series Mac, Z-Image is known to hang the system — stick to SD 1.5 there.
For SD 1.5 on M2: expect ~1–2 s/step with the Metal dylib active. If you see ~10 s/step instead, the binary may have fallen back to CPU — see verification below.

Verifying the SD 1.5 path (the fastest sanity test on Mac)

If you want to confirm sd.cpp is installed correctly without going through the UI, you can drive sd-cli directly. This is the same binary the app uses.

# 1. App data layout (created on first app launch)
APP_DATA="$HOME/Library/Application Support/open-generative-ai/local-ai"
ls "$APP_DATA/bin"     # sd-cli, libstable-diffusion.dylib
ls "$APP_DATA/models"  # whatever you've downloaded

# 2. Grab a small SD 1.5 model directly (Dreamshaper 8, ~2 GB)
curl -L --fail --progress-bar \
  -o "$APP_DATA/models/DreamShaper_8_pruned.safetensors" \
  "https://huggingface.co/Lykon/DreamShaper/resolve/main/DreamShaper_8_pruned.safetensors"

# 3. Run a single 512x512 / 12-step inference
DYLD_LIBRARY_PATH="$APP_DATA/bin" "$APP_DATA/bin/sd-cli" \
  -m "$APP_DATA/models/DreamShaper_8_pruned.safetensors" \
  -p "a serene mountain lake at sunrise, oil painting" \
  -o /tmp/sd15-test.png \
  --steps 12 -H 512 -W 512 --cfg-scale 7.5 --seed 42 \
  --sampling-method euler_a

A healthy run on Apple Silicon prints total params memory size = 1969.78MB (VRAM 1969.78MB, RAM 0.00MB) (Metal-backed) and produces a coherent 512×512 PNG. If VRAM is 0.00MB instead, the dylib is CPU-only — check otool -L "$APP_DATA/bin/libstable-diffusion.dylib" | grep -i metal and reinstall the engine from Settings → Local Models if Metal is missing.

✨ Features

Image Studio — Generate images from text prompts (50+ text-to-image models) or transform existing images (55+ image-to-image models). Switches model set automatically based on whether a reference image is provided. Quality and resolution controls visible for models that support them.
Local Inference — Two engines: sd.cpp (bundled, runs on Mac/Win/Linux with Metal/CUDA/Vulkan/ROCm) for SD 1.5, SDXL, and Z-Image; and Wan2GP (BYO Gradio server) for Flux, Qwen-Image, and video models (Wan 2.2, Hunyuan, LTX). Configure both in Settings → Local Models.
Multi-Image Input — Upload up to 14 reference images for compatible edit models (Nano Banana 2 Edit, Flux Kontext Dev, GPT-4o Edit, and more). Multi-select picker with order badges, batch upload, and a "Use Selected" confirmation flow.
Video Studio — Generate videos from text prompts (40+ text-to-video models) or animate a start-frame image (60+ image-to-video models). Same intelligent mode switching as Image Studio.
Lip Sync Studio — Animate portrait images or sync lips on existing videos using audio. 9 dedicated models across two modes: portrait image + audio → talking video, and video + audio → lipsync video.
Cinema Studio — Interface for photorealistic cinematic shots with pro camera controls (Lens, Focal Length, Aperture)
Workflow Studio — Build and run multi-step AI pipelines visually. Chain image, video, and audio models into automated flows. Browse community templates, create your own with a node-based editor, and run them via an interactive playground.
Upload History — Reference images are uploaded once and stored locally. A picker panel lets you reuse any previously uploaded image across sessions — no re-uploading.
Smart Controls — Dynamic aspect ratio, resolution/quality, and duration pickers that adapt to each model's capabilities (including t2i models with resolution or quality options)
Generation History — Browse, revisit, and download all past generations (persisted in browser storage)
Image & Video Download — One-click download of generated outputs in full resolution
API Key Management — Secure API key storage in browser localStorage (never sent to any server except Muapi)
Responsive Design — Works seamlessly on desktop and mobile with dark glassmorphism UI

🖼️ Image Studio — Dual Mode

The Image Studio automatically switches between two model sets:

Mode	Trigger	Models	Prompt
Text-to-Image	Default (no image)	50+ t2i models (Flux, Nano Banana 2, Seedream 5.0, Ideogram, GPT-4o, Midjourney…)	Required
Image-to-Image	Reference image uploaded	55+ i2i models (Kontext, Nano Banana 2 Edit, Seedream 5.0 Edit, Seededit, Upscaler…)	Optional

Newly Added Models

Model	Type	Key Features
Nano Banana 2	Text-to-Image	Google Gemini 3.1 Flash Image · Resolution 1K/2K/4K · Google Search enhancement · aspect ratio `auto`
Nano Banana 2 Edit	Image-to-Image	Up to 14 reference images · Resolution 1K/2K/4K · Google Search enhancement
Seedream 5.0	Text-to-Image	ByteDance · Quality basic/high · 8 aspect ratios · up to 4K
Seedream 5.0 Edit	Image-to-Image	ByteDance · Natural language style transfer · Quality basic/high
MiniMax Image 01	Text-to-Image	MiniMax · 8 aspect ratios · up to 4 images per request · 1500 char prompt

Multi-Image Input

Models that accept multiple reference images expose a multi-select picker when active:

Model	Max Images
Nano Banana 2 Edit	14
Nano Banana Edit	10
Flux Kontext Dev I2I	10
Kling O1 Edit Image	10
GPT-4o Edit / GPT Image 1.5 Edit	10
Bytedance Seedream Edit v4 / v4.5	10
Vidu Q2 Reference to Image	7
Flux 2 Flex/Pro Edit	8
Nano Banana Pro Edit	8
Flux Kontext Pro/Max I2I	2
Wan 2.5/2.6 Image Edit	2–3
Qwen Image Edit Plus / 2511	3
GPT-4o Image to Image	5
Flux 2 Klein 4b/9b Edit	4

When a multi-image model is selected the upload trigger switches to multi-select mode:

Checkboxes with order numbers — images are sent to the model in the order you select them
Batch upload — pick multiple files at once from your file dialog
Count badge on the trigger shows how many images are active; a + badge appears when more slots are available
"Use Selected" button confirms and closes the picker

🎬 Video Studio — Dual Mode

The Video Studio follows the same pattern:

Mode	Trigger	Models	Prompt
Text-to-Video	Default (no image)	40+ t2v models (Kling, Sora, Veo, Wan, Seedance 2.0, Hailuo, Runway…)	Required
Image-to-Video	Start frame uploaded	60+ i2v models (Kling I2V, Veo3 I2V, Runway I2V, Wan I2V, Seedance 2.0 I2V, Midjourney I2V…)	Optional

Newly Added Models

Model	Type	Key Features
Seedance 2.0	Text-to-Video	ByteDance · Aspect ratios 16:9 / 9:16 / 4:3 / 3:4 · Duration 5 / 10 / 15s · Quality basic/high
Seedance 2.0 I2V	Image-to-Video	ByteDance · Animate images into video · Up to 9 reference images · Aspect ratios 16:9 / 9:16 / 4:3 / 3:4 · Duration 5 / 10 / 15s · Quality basic/high
Seedance 2.0 Extend	Video Extension	ByteDance · Seamlessly continue any Seedance 2.0 generation · Preserves style, motion & audio · Optional continuation prompt · Duration 5 / 10 / 15s · Quality basic/high
Grok Imagine T2V	Text-to-Video	xAI · Duration 6 / 10 / 15s · Modes: fun / normal / spicy · Aspect ratios 9:16 / 16:9 / 2:3 / 3:2 / 1:1
Grok Imagine I2V	Image-to-Video	xAI · Duration 6 / 10 / 15s · Modes: fun / normal / spicy · Cinematic motion from still images
MiniMax Hailuo 02 / 2.3 Standard & Pro	Text-to-Video / Image-to-Video	MiniMax · Full HD video · Multiple aspect ratios · Fast variant included

🎙️ Lip Sync Studio

The Lip Sync Studio generates audio-driven talking videos using 9 models across two input modes:

Mode	Trigger	Description
Portrait Image	Default	Upload a portrait image + audio file → animated talking video
Video	Switch to Video mode	Upload an existing video + audio file → lipsync video

Image-based Models (Portrait Image + Audio → Video)

Model	Endpoint	Resolutions	Prompt
Infinite Talk	`infinitetalk-image-to-video`	480p, 720p	Optional
Wan 2.2 Speech to Video	`wan2.2-speech-to-video`	480p, 720p	Optional
LTX 2.3 Lipsync	`ltx-2.3-lipsync`	480p, 720p, 1080p	Optional
LTX 2 19B Lipsync	`ltx-2-19b-lipsync`	480p, 720p, 1080p	Optional

Video-based Models (Video + Audio → Lipsync Video)

Model	Endpoint	Resolutions	Prompt
Sync Lipsync	`sync-lipsync`	—	—
LatentSync	`latentsync-video`	—	—
Creatify Lipsync	`creatify-lipsync`	—	—
Veed Lipsync	`veed-lipsync`	—	—
Infinite Talk V2V	`infinitetalk-video-to-video`	480p, 720p	Optional

How it works:

Select Portrait Image or Video mode using the toggle
Upload your portrait image (or video) using the image/video upload button
Upload your audio file using the audio upload button
Optionally enter a prompt to guide the motion style
Select a model and resolution (where supported), then click Generate

Generation history is saved separately in lipsync_history and pending jobs resume automatically on page reload.

🔀 Workflow Studio

The Workflow Studio lets you build and run multi-step AI pipelines without writing code.

Key capabilities:

Templates — Start from pre-built workflows (image chains, video pipelines, and more)
My Workflows — Save and manage your own custom pipelines
Community — Browse and run workflows published by other users
Node-based Builder — Drag-and-drop visual editor to connect models and route outputs between steps
Playground — Run any workflow interactively with a form UI; results render inline
API execution — Every workflow is also callable via the Muapi API

💡 Want to add workflows to your own app? Check out Vibe Workflow — the open-source workflow engine powering this feature. Drop it into any project.

🎥 Cinema Studio Controls

The Cinema Studio offers precise control over the virtual camera, translating your choices into optimized prompt modifiers:

Category	Available Options
Cameras	Modular 8K Digital, Full-Frame Cine Digital, Grand Format 70mm Film, Studio Digital S35, Classic 16mm Film, Premium Large Format Digital
Lenses	Creative Tilt, Compact Anamorphic, Extreme Macro, 70s Cinema Prime, Classic Anamorphic, Premium Modern Prime, Warm Cinema Prime, Swirl Bokeh Portrait, Vintage Prime, Halation Diffusion, Clinical Sharp Prime
Focal Lengths	8mm (Ultra-Wide), 14mm, 24mm, 35mm (Human Eye), 50mm (Portrait), 85mm (Tight Portrait)
Apertures	f/1.4 (Shallow DoF), f/4 (Balanced), f/11 (Deep Focus)

📁 Upload History & Picker

Every image you upload is saved locally (URL + thumbnail) so you never upload the same file twice:

Click the upload button to open the reference image picker
Previously uploaded images appear in a 3-column grid with thumbnails
Single-image models — click a thumbnail to instantly select and close
Multi-image models — toggle multiple thumbnails (shown with order numbers), then click Use Selected
Upload new images with the Upload files button (supports multi-file selection in multi-image mode)
Remove individual images from history with the ✕ button
History persists across browser sessions (stored in localStorage)

🚀 Quick Start

Prerequisites

Node.js (v18+)
A Muapi.ai API key

Setup

Most users want the desktop app, not this dev path. If you just want to run Open Generative AI on your machine, download a prebuilt installer instead — no Node.js required. The instructions below are for contributors building from source.

Pick the entry point that matches your goal:

Desktop app (Electron) → npm run electron:dev
Hosted web version (Next.js) → npm run dev

# Clone the repository (with submodules — required for the workflow + agent packages)
git clone --recurse-submodules https://github.com/Anil-matcha/Open-Generative-AI.git
cd Open-Generative-AI

# If you already cloned without --recurse-submodules, run this once:
# git submodule update --init --recursive

# Install dependencies + build workspace packages (studio, workflow, agents).
# This step is REQUIRED — `npm install` alone is not enough; the workspaces
# need to be built before either dev script will work.
npm run setup

# Then start ONE of:
npm run electron:dev   # Desktop app (Electron + Vite) — recommended
npm run dev            # Hosted web version (Next.js) → http://localhost:3000

You'll be prompted to enter your Muapi API key on first use (skip the key if you only plan to use local models).

Troubleshooting — Couldn't find a 'pages' directory: this means Next.js can't see the app/ folder. Confirm you're running npm run dev from the repo root (the directory that contains app/, package.json, and next.config.mjs), and that you cloned with submodules. Re-run npm run setup if packages/Vibe-Workflow or packages/Open-Poe-AI are empty.

Production Build

npm run build
npm run start

Desktop App Build

Build native desktop apps with Electron:

# macOS (DMG — Intel + Apple Silicon)
npm run electron:build

# Windows (NSIS installer — x64 + ARM64)
npm run electron:build:win

# Linux (AppImage + DEB — x64)
npm run electron:build:linux

# Both platforms in one pass
npm run electron:build:all

Installers are output to the release/ folder. Pre-built binaries are also available on the Releases page.

🏗️ Architecture

The app is a Next.js monorepo with a shared packages/studio component library.

Open-Generative-AI/
├── app/                        # Next.js App Router
│   ├── layout.js               # Root layout (Tailwind, fonts)
│   ├── page.js                 # Redirects → /studio
│   └── studio/
│       └── page.js             # Studio page — renders StandaloneShell
├── components/
│   ├── StandaloneShell.js      # Tab nav + BYOK (API key from localStorage)
│   └── ApiKeyModal.js          # API key entry modal
├── packages/
│   └── studio/                 # Shared React component library
│       └── src/
│           ├── index.js        # Exports: ImageStudio, VideoStudio, LipSyncStudio, CinemaStudio, WorkflowStudio
│           ├── models.js       # 200+ model definitions (single source of truth)
│           ├── muapi.js        # API client (named exports, apiKey as first param)
│           └── components/
│               ├── ImageStudio.jsx    # Dual-mode t2i/i2i studio
│               ├── VideoStudio.jsx    # Dual-mode t2v/i2v studio
│               ├── LipSyncStudio.jsx  # Portrait/video + audio → talking video
│               ├── CinemaStudio.jsx   # Pro studio with camera controls
│               └── WorkflowStudio.jsx # Multi-step pipeline builder & playground
├── next.config.mjs             # transpilePackages: ['studio']
├── tailwind.config.js
└── package.json                # workspaces: ["packages/studio"]

The packages/studio library is also consumed by the hosted version on muapi.ai — model updates made in packages/studio/src/models.js apply to both the self-hosted app and the hosted version automatically.

🔌 API Integration

The app communicates with Muapi.ai using a two-step pattern:

Submit — POST /api/v1/{model-endpoint} with prompt and parameters
Poll — GET /api/v1/predictions/{request_id}/result until status is completed

Authentication uses the x-api-key header. During development, a Vite proxy handles CORS by routing /api requests to https://api.muapi.ai.

File uploads use POST /api/v1/upload_file (multipart/form-data) and return a hosted URL that is passed to image-conditioned models. For multi-image models the full images_list array is forwarded to the API in one request.

Lip sync jobs use the same two-step pattern: a dedicated processLipSync() method accepts image_url or video_url alongside audio_url, dispatches to the model's endpoint, and polls until the output video URL is available.

🎨 Supported Model Categories

Category	Count	Examples
Text-to-Image	50+	Flux Dev, Nano Banana 2, Seedream 5.0, Ideogram v3, Midjourney v7, GPT-4o, SDXL
Image-to-Image	55+	Nano Banana 2 Edit (×14), Flux Kontext Pro, GPT-4o Edit, Seededit v3, Upscaler, Background Remover
Text-to-Video	40+	Kling v3, Sora 2, Veo 3, Wan 2.6, Seedance 2.0, Seedance 2.0 Extend, Seedance Pro, Hailuo 2.3, Runway Gen-3
Image-to-Video	60+	Kling v2.1 I2V, Veo3 I2V, Runway I2V, Seedance 2.0 I2V, Midjourney v7 I2V, Hunyuan I2V, Wan2.2 I2V
Lip Sync	9	Infinite Talk I2V, Wan 2.2 Speech to Video, LTX 2.3 Lipsync, LTX 2 19B Lipsync, Sync, LatentSync, Creatify, Veed, Infinite Talk V2V

🛠️ Tech Stack

Next.js 14 — App Router, server components, fast dev server
React 18 — Studio UI components
Tailwind CSS v3 — Utility-first styling
npm workspaces — Monorepo with shared packages/studio library
Muapi.ai — AI model API gateway

🤔 How is this different from other AI Video Plaforms?

Open Generative AI is a community-driven, open-source alternative that provides similar creative capabilities without the closed ecosystem:

	Other providers	Open Generative AI
Cost	Subscription-based	Free (open-source)
Content filters	Yes — prompts blocked or altered	None
Restrictions	Platform guardrails enforced	Full creative freedom
Models	Proprietary	200+ open & commercial models
Multi-image input	Limited	Up to 14 images per request
Lip sync	No	9 models, image & video modes
Hosted version	Subscription	Free at muapi.ai/open-generative-ai
Self-hosting	No	Yes
Customizable	No	Fully hackable
Data privacy	Cloud-based	Your data stays local
Source code	Closed	MIT licensed

📄 License

MIT

🙏 Credits

Built with Muapi.ai — the unified API for AI image and video generation models.

Deep Dive: For more details on the "AI Influencer" engine, upcoming "Popcorn" storyboarding features, and the future of this project, read the full technical overview.

Looking for a free, open-source AI Video Platform? Open Generative AI is an open-source AI image and video generation studio — with no content filters that you can self-host, customize, and extend.

coreyhaines31/marketingskills

Marketing skills for Claude Code and AI agents. CRO, copywriting, SEO, analytics, and growth engineering.

Marketing Skills for AI Agents

A collection of AI agent skills focused on marketing tasks. Built for technical marketers and founders who want AI coding agents to help with conversion optimization, copywriting, SEO, analytics, and growth engineering. Works with Claude Code, OpenAI Codex, Cursor, Windsurf, and any agent that supports the Agent Skills spec.

Built by Corey Haines. Need hands-on help? Check out Conversion Factory — Corey's agency for conversion optimization, landing pages, and growth strategy. Want to learn more about marketing? Subscribe to Swipe Files. Want an autonomous AI agent that uses these skills to be your CMO? Try Magister.

New to the terminal and coding agents? Check out the companion guide Coding for Marketers.

Contributions welcome! Found a way to improve a skill or have a new one to add? Open a PR.

Run into a problem or have a question? Open an issue — we're happy to help.

What are Skills?

Skills are markdown files that give AI agents specialized knowledge and workflows for specific tasks. When you add these to your project, your agent can recognize when you're working on a marketing task and apply the right frameworks and best practices.

How Skills Work Together

Skills reference each other and build on shared context. The product-marketing skill is the foundation — every other skill checks it first to understand your product, audience, and positioning before doing anything.

                            ┌──────────────────────────────────────┐
                            │          product-marketing           │
                            │    (read by all other skills first)  │
                            └──────────────────┬───────────────────┘
                                               │
    ┌──────────────┬─────────────┬─────────────┼─────────────┬──────────────┬──────────────┐
    ▼              ▼             ▼             ▼             ▼              ▼              ▼
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌────────────┐ ┌──────────┐ ┌─────────────┐ ┌───────────┐
│  SEO &   │ │   CRO    │ │Content & │ │  Paid &    │ │ Growth & │ │  Sales &    │ │ Strategy  │
│ Content  │ │          │ │   Copy   │ │Measurement │ │Retention │ │    GTM      │ │           │
├──────────┤ ├──────────┤ ├──────────┤ ├────────────┤ ├──────────┤ ├─────────────┤ ├───────────┤
│seo-audit │ │cro       │ │copywritng│ │ads         │ │referrals │ │revops       │ │mktg-ideas │
│ai-seo    │ │signup    │ │copy-edit │ │ad-creative │ │free-tools│ │sales-enable │ │mktg-psych │
│site-arch │ │onboarding│ │cold-email│ │ab-testing  │ │churn-    │ │launch       │ │customer-  │
│programm  │ │popups    │ │emails    │ │analytics   │ │ prevent  │ │pricing      │ │ research  │
│schema    │ │paywalls  │ │social    │ │            │ │community │ │competitors  │ │           │
│content   │ │          │ │video     │ │            │ │lead-magnt│ │comp-profile │ │           │
│aso       │ │          │ │image     │ │            │ │co-mktg   │ │directory    │ │           │
└────┬─────┘ └────┬─────┘ └────┬─────┘ └─────┬──────┘ └────┬─────┘ └──────┬──────┘ └─────┬─────┘
     │            │            │              │             │              │              │
     └────────────┴─────┬──────┴──────────────┴─────────────┴──────────────┴──────────────┘
                        │
         Skills cross-reference each other:
           copywriting ↔ cro ↔ ab-testing
           revops ↔ sales-enablement ↔ cold-email
           seo-audit ↔ schema ↔ ai-seo
           customer-research → copywriting, cro, competitors

See each skill's Related Skills section for the full dependency map.

Available Skills

Skill	Description
ab-testing	When the user wants to plan, design, or implement an A/B test or experiment, or build a growth experimentation program....
ad-creative	When the user wants to generate, iterate, or scale ad creative — headlines, descriptions, primary text, or full ad...
ads	When the user wants help with paid advertising campaigns on Google Ads, Meta (Facebook/Instagram), LinkedIn, Twitter/X,...
ai-seo	When the user wants to optimize content for AI search engines, get cited by LLMs, or appear in AI-generated answers....
analytics	When the user wants to set up, improve, or audit analytics tracking and measurement. Also use when the user mentions...
aso	When the user wants to audit or optimize an App Store or Google Play listing. Also use when the user mentions 'ASO...
churn-prevention	When the user wants to reduce churn, build cancellation flows, set up save offers, recover failed payments, or...
co-marketing	When the user wants to find co-marketing partners, plan joint campaigns, or brainstorm partnership opportunities. Use...
cold-email	Write B2B cold emails and follow-up sequences that get replies. Use when the user wants to write cold outreach emails,...
community-marketing	Build and leverage online communities to drive product growth and brand loyalty. Use when the user wants to create a...
competitor-profiling	When the user wants to research, profile, or analyze competitors from their URLs. Also use when the user mentions...
competitors	When the user wants to create competitor comparison or alternative pages for SEO and sales enablement. Also use when...
content-strategy	When the user wants to plan a content strategy, decide what content to create, or figure out what topics to cover. Also...
copy-editing	When the user wants to edit, review, or improve existing marketing copy, or refresh outdated content. Also use when the...
copywriting	When the user wants to write, rewrite, or improve marketing copy for any page — including homepage, landing pages,...
cro	When the user wants to optimize, improve, or increase conversions on any marketing page or form — including homepage,...
customer-research	When the user wants to conduct, analyze, or synthesize customer research. Use when the user mentions "customer...
directory-submissions	When the user wants to submit their product to startup, SaaS, AI, agent, MCP, no-code, or review directories for...
emails	When the user wants to create or optimize an email sequence, drip campaign, automated email flow, or lifecycle email...
free-tools	When the user wants to plan, evaluate, or build a free tool for marketing purposes — lead generation, SEO value, or...
image	When the user wants to create, generate, edit, or optimize images for marketing — blog heroes, social graphics, product...
launch	When the user wants to plan a product launch, feature announcement, or release strategy. Also use when the user...
lead-magnets	When the user wants to create, plan, or optimize a lead magnet for email capture or lead generation. Also use when the...
marketing-ideas	When the user needs marketing ideas, inspiration, or strategies for their SaaS or software product. Also use when the...
marketing-psychology	When the user wants to apply psychological principles, mental models, or behavioral science to marketing. Also use when...
onboarding	When the user wants to optimize post-signup onboarding, user activation, first-run experience, or time-to-value. Also...
paywalls	When the user wants to create or optimize in-app paywalls, upgrade screens, upsell modals, or feature gates. Also use...
popups	When the user wants to create or optimize popups, modals, overlays, slide-ins, or banners for conversion purposes. Also...
pricing	When the user wants help with pricing decisions, packaging, or monetization strategy. Also use when the user mentions...
product-marketing	When the user wants to create or update their product marketing context document. Also use when the user mentions...
programmatic-seo	When the user wants to create SEO-driven pages at scale using templates and data. Also use when the user mentions...
referrals	When the user wants to create, optimize, or analyze a referral program, affiliate program, or word-of-mouth strategy....
revops	When the user wants help with revenue operations, lead lifecycle management, or marketing-to-sales handoff processes....
sales-enablement	When the user wants to create sales collateral, pitch decks, one-pagers, objection handling docs, or demo scripts. Also...
schema	When the user wants to add, fix, or optimize schema markup and structured data on their site. Also use when the user...
seo-audit	When the user wants to audit, review, or diagnose SEO issues on their site. Also use when the user mentions "SEO...
signup	When the user wants to optimize signup, registration, account creation, or trial activation flows. Also use when the...
site-architecture	When the user wants to plan, map, or restructure their website's page hierarchy, navigation, URL structure, or internal...
social	When the user wants help creating, scheduling, or optimizing social media content for LinkedIn, Twitter/X, Instagram,...
video	When the user wants to create, generate, or produce video content using AI tools or programmatic frameworks. Also use...

Installation

Option 1: CLI Install (Recommended)

Use npx skills to install skills directly:

# Install all skills
npx skills add coreyhaines31/marketingskills

# Install specific skills
npx skills add coreyhaines31/marketingskills --skill cro copywriting

# List available skills
npx skills add coreyhaines31/marketingskills --list

This automatically installs to your .agents/skills/ directory (and symlinks into .claude/skills/ for Claude Code compatibility).

Option 2: Claude Code Plugin

Install via Claude Code's built-in plugin system:

# Add the marketplace
/plugin marketplace add coreyhaines31/marketingskills

# Install all marketing skills
/plugin install marketing-skills

Option 3: Clone and Copy

Clone the entire repo and copy the skills folder:

git clone https://github.com/coreyhaines31/marketingskills.git
cp -r marketingskills/skills/* .agents/skills/

Option 4: Git Submodule

Add as a submodule for easy updates:

git submodule add https://github.com/coreyhaines31/marketingskills.git .agents/marketingskills

Then reference skills from .agents/marketingskills/skills/.

Option 5: Fork and Customize

Fork this repository
Customize skills for your specific needs
Clone your fork into your projects

Option 6: SkillKit (Multi-Agent)

Use SkillKit to install skills across multiple AI agents (Claude Code, Cursor, Copilot, etc.):

# Install all skills
npx skillkit install coreyhaines31/marketingskills

# Install specific skills
npx skillkit install coreyhaines31/marketingskills --skill cro copywriting

# List available skills
npx skillkit install coreyhaines31/marketingskills --list

Upgrading from v1.x to v2.0

v2.0 renames 17 skills and consolidates page-cro + form-cro into a single cro skill. If you installed the v1.x skills, you'll have stale old-name folders in your install directory after upgrading — the new skills install alongside the old ones, so you'll see both skills/page-cro/ and skills/cro/, etc. Clean them up:

# From the directory where you installed the skills (e.g., .agents/skills/ or .claude/skills/)
rm -rf page-cro form-cro \
       ab-test-setup analytics-tracking aso-audit competitor-alternatives \
       email-sequence free-tool-strategy launch-strategy onboarding-cro \
       paid-ads paywall-upgrade-cro popup-cro pricing-strategy \
       product-marketing-context referral-program schema-markup \
       signup-flow-cro social-content

Then reinstall the v2.0 skills via your usual method (e.g., npx skills add coreyhaines31/marketingskills).

Migrate the product marketing context file

In v2.0 the context file moved from .claude/ to .agents/ and was renamed from product-marketing-context.md to product-marketing.md. Move your existing context file:

mkdir -p .agents
# v2.0 file (or pre-v2.0 file with new name)
mv .claude/product-marketing.md .agents/product-marketing.md 2>/dev/null
# pre-v2.0 file with legacy name
mv .claude/product-marketing-context.md .agents/product-marketing.md 2>/dev/null

Skills will still check .claude/ and the legacy product-marketing-context.md filename as fallbacks, so nothing breaks if you don't migrate.

Full rename map

Old	New
`ab-test-setup`	`ab-testing`
`analytics-tracking`	`analytics`
`aso-audit`	`aso`
`competitor-alternatives`	`competitors`
`email-sequence`	`emails`
`form-cro`	merged into `cro`
`free-tool-strategy`	`free-tools`
`launch-strategy`	`launch`
`onboarding-cro`	`onboarding`
`page-cro`	`cro`
`paid-ads`	`ads`
`paywall-upgrade-cro`	`paywalls`
`popup-cro`	`popups`
`pricing-strategy`	`pricing`
`product-marketing-context`	`product-marketing`
`referral-program`	`referrals`
`schema-markup`	`schema`
`signup-flow-cro`	`signup`
`social-content`	`social`

Usage

Once installed, just ask your agent to help with marketing tasks:

"Help me optimize this landing page for conversions"
→ Uses cro skill

"Write homepage copy for my SaaS"
→ Uses copywriting skill

"Set up GA4 tracking for signups"
→ Uses analytics skill

"Create a 5-email welcome sequence"
→ Uses emails skill

You can also invoke skills directly:

/cro
/emails
/seo-audit

Skill Categories

Conversion Optimization

cro - Pages and forms
signup - Registration flows
onboarding - Post-signup activation
popups - Modals and overlays
paywalls - In-app upgrade moments

Content & Copy

copywriting - Marketing page copy
copy-editing - Edit and polish existing copy
cold-email - B2B cold outreach emails and sequences
emails - Automated email flows
social - Social media content
image - AI image generation, design tools, and optimization

SEO & Discovery

seo-audit - Technical and on-page SEO
ai-seo - AI search optimization (AEO, GEO, LLMO)
programmatic-seo - Scaled page generation
site-architecture - Page hierarchy, navigation, URL structure
competitors - Comparison and alternative pages
schema - Structured data

Paid & Distribution

ads - Google, Meta, LinkedIn ad campaigns
ad-creative - Bulk ad creative generation and iteration
social - Social media scheduling and strategy

Measurement & Testing

analytics - Event tracking setup
ab-testing - Experiment design

Retention

churn-prevention - Cancel flows, save offers, dunning, payment recovery

Growth Engineering

co-marketing - Partner identification and joint campaigns
free-tools - Marketing tools and calculators
referrals - Referral and affiliate programs

Strategy & Monetization

marketing-ideas - 140 SaaS marketing ideas
marketing-psychology - Mental models and psychology
launch - Product launches and announcements
pricing - Pricing, packaging, and monetization

Sales & RevOps

revops - Lead lifecycle, scoring, routing, pipeline management
sales-enablement - Sales decks, one-pagers, objection docs, demo scripts

Contributing

Found a way to improve a skill? Have a new skill to suggest? PRs and issues welcome!

See CONTRIBUTING.md for guidelines on adding or improving skills.

License

MIT - Use these however you want.

gsd-build/get-shit-done

A light-weight and powerful meta-prompting, context engineering and spec-driven development system for Claude Code by TÂCHES.

GET SHIT DONE

English · Português · 简体中文 · 日本語 · 한국어

A light-weight meta-prompting, context engineering, and spec-driven development system for Claude Code, OpenCode, Gemini CLI, Kilo, Codex, Copilot, Cursor, Windsurf, and more.

Solves context rot — the quality degradation that happens as your AI fills its context window.

npx get-shit-done-cc@latest

Works on Mac, Windows, and Linux.

"If you know clearly what you want, this WILL build it for you. No bs."

"I've done SpecKit, OpenSpec and Taskmaster — this has produced the best results for me."

"By far the most powerful addition to my Claude Code. Nothing over-engineered. Literally just gets shit done."

Trusted by engineers at Amazon, Google, Shopify, and Webflow.

Important

Returning to GSD?

Run /gsd-map-codebase to re-index your codebase, then /gsd-new-project to rebuild GSD's planning context. Your code is fine — GSD just needs its context rebuilt. See the CHANGELOG for what's new.

Why I Built This

I'm a solo developer. I don't write code — Claude Code does.

Other spec-driven tools exist, but they're all built for 50-person engineering orgs — sprint ceremonies, story points, stakeholder syncs, Jira workflows. I'm not that. I'm a creative person trying to build great things consistently.

So I built GSD. The complexity is in the system, not in your workflow. Behind the scenes: context engineering, XML prompt formatting, subagent orchestration, state management. What you see: a few commands that just work.

The system gives Claude everything it needs to do the work and verify it. I trust the workflow. It just does a good job.

— TÂCHES

How It Works

The loop is six commands. Each one does exactly one thing.

1. Initialize

/gsd-new-project

Questions → research → requirements → roadmap. You approve it, then you're ready to build.

Already have code? Run /gsd-map-codebase first. It analyzes your stack, architecture, and conventions so /gsd-new-project asks the right questions.

2. Discuss

/gsd-discuss-phase 1

Your roadmap has a sentence per phase. That's not enough to build it the way you imagine it. Discuss captures your decisions before anything gets planned: layouts, API shapes, error handling, data structures — whatever gray areas exist for this specific phase.

The output feeds directly into research and planning. Skip it, get reasonable defaults. Use it, get your vision.

3. Plan

/gsd-plan-phase 1

Research → plan → verify, in a loop until the plans pass. Each plan is small enough to execute in a fresh context window.

4. Execute

/gsd-execute-phase 1

Plans run in parallel waves. Each executor gets a fresh 200k-token context. Each task gets its own atomic commit. Walk away, come back to completed work with a clean git history.

Your main context window stays at 30–40%. The work happens in the subagents.

5. Verify

/gsd-verify-work 1

Walk through what was built. Anything broken gets a diagnosed fix plan — ready for immediate re-execution. You don't debug manually; you just run execute again.

6. Repeat → Ship

/gsd-ship 1
/gsd-complete-milestone
/gsd-new-milestone

Loop discuss → plan → execute → verify → ship until the milestone is done. Then archive, tag, and start the next one fresh.

Getting Started

npx get-shit-done-cc@latest

The installer prompts for your runtime (Claude Code, OpenCode, Gemini CLI, Kilo, Codex, Copilot, Cursor, Windsurf, and more) and whether to install globally or locally.

claude --dangerously-skip-permissions

GSD is built for frictionless automation. Skip-permissions is how it's intended to run.

Install only the skills you need with --profile=core (six core-loop skills), --profile=standard (core + phase management), or the default full install. Profiles compose: --profile=core,audit. --minimal is an alias for --profile=core. See docs/USER-GUIDE.md for the full walkthrough, non-interactive install flags for all 15 runtimes, and permissions configuration. See ADR-0011 for the profile model and runtime surface control.

Current release highlights are in docs/RELEASE-v1.42.1.md: package legitimacy checks, safer installer migrations, runtime surface control, custom ship PR sections, reviewer defaults, fallow structural review, and quota-aware execution recovery.

Commands

The main loop:

Command	What it does
`/gsd-new-project`	Questions → research → requirements → roadmap
`/gsd-discuss-phase [N]`	Capture implementation decisions before planning
`/gsd-plan-phase [N]`	Research + plan + verify
`/gsd-execute-phase <N>`	Execute plans in parallel waves
`/gsd-verify-work [N]`	Manual acceptance testing
`/gsd-ship [N]`	Create PR from verified phase work
`/gsd-progress --next`	Auto-detect and run the next step
`/gsd-complete-milestone`	Archive milestone and tag release
`/gsd-new-milestone`	Start next version
`/gsd:surface`	Enable/disable skill clusters at runtime without reinstall

For ad-hoc tasks, autonomous mode, codebase analysis, forensics, and the full command surface — see docs/COMMANDS.md.

Why It Works

Three things most AI-coding setups get wrong:

1. Context bloat. As a session grows, quality degrades. GSD keeps your main context clean by doing the heavy work in fresh subagent contexts. Researchers, planners, and executors each start fresh with exactly what they need.

2. No shared memory. GSD maintains structured artifacts that survive session boundaries: PROJECT.md (vision), REQUIREMENTS.md (scope), ROADMAP.md (where you're going), STATE.md (current position and decisions), CONTEXT.md (per-phase implementation decisions). Every new session loads these and knows exactly where things stand.

3. No verification. Code that "runs" isn't code that "works." GSD's verify step walks you through what was built, diagnoses failures with dedicated debug agents, and generates fix plans before you declare a phase done.

See docs/ARCHITECTURE.md for how the multi-agent orchestration and context engineering work in detail.

Configuration

Settings live in .planning/config.json. Configure during /gsd-new-project or update with /gsd-settings.

Key dials:

Setting	What it controls
`mode`	`interactive` (confirm each step) or `yolo` (auto-approve)
Model profiles	`quality` / `balanced` / `budget` — controls which model each agent uses
`workflow.research` / `plan_check` / `verifier`	Toggle the quality agents that add tokens and time
`parallelization.enabled`	Run independent plans simultaneously

Optional structural review: set code_quality.fallow.enabled to true to add a fallow pre-pass to /gsd-code-review. GSD writes .planning/phases/<phase>/FALLOW.json and surfaces a Structural Findings (fallow) section in REVIEW.md. Install with npm install -D fallow@^2.70.0 (or system-wide via cargo install fallow; note that the Rust binary's JSON schema must match the documented v2.70+ contract — older versions may produce silent zero-finding output).

Package legitimacy checks are built into the research, planning, and execution path: recommended dependencies get audited, unverified packages require a human checkpoint, and failed installs stop instead of trying similarly named alternatives.

For the full configuration reference — all settings, git branching strategies, per-runtime model overrides, workstream config inheritance, agent skills injection — see docs/CONFIGURATION.md.

Documentation

Doc	What's in it
User Guide	End-to-end walkthrough, install options, all runtime flags, configuration reference
Commands	Every command with flags and examples
Configuration	Full config schema, model profiles, git branching
Architecture	How the multi-agent orchestration works
CLI Tools	`gsd-sdk query` and programmatic SDK dispatch seams
Features	Complete feature index
Changelog	What changed in each release

Troubleshooting

Commands not showing up? Restart your runtime after install. GSD installs to ~/.claude/skills/gsd-*/ (Claude Code), ~/.codex/skills/gsd-*/ (Codex), or the equivalent for your runtime.

Codex users — minimum supported CLI version is 0.130.0. Codex CLI 0.130.0 (release notes) removed extra-skill-roots discovery via openai/codex#21485; from that version onward Codex discovers skills from standard roots (including ~/.codex/skills/<name>/SKILL.md). GSD installs there directly. Earlier Codex CLI versions may still discover additional roots, which can surface duplicate gsd-* entries (one from extra-roots discovery, one from ~/.codex/skills/); restart Codex after install and either upgrade or accept the duplicate listing.

Something broken? Re-run the installer — it's idempotent:

npx get-shit-done-cc@latest

Containers or Docker? Set CLAUDE_CONFIG_DIR before installing to avoid tilde-expansion issues:

CLAUDE_CONFIG_DIR=/home/youruser/.claude npx get-shit-done-cc --global

Full troubleshooting and uninstall instructions in docs/USER-GUIDE.md.

Community

Project	Platform
gsd-opencode	Original OpenCode port
Discord	Community support

Star History

License

MIT License. See LICENSE for details.

Claude Code is powerful. GSD makes it reliable.

oracle/skills

Oracle DB Skills is a curated library of 100+ practical, documentation-backed guides for working with Oracle Database, organized by domain

Oracle Skills

Oracle Skills is a collection of practical, installable skills for working with Oracle technologies.

The goal is to give developers and agents a single place to find source-backed Oracle guidance across Oracle Database, Oracle Cloud Infrastructure, GraalVM, Oracle Fusion, Oracle APEX, and future domains.

Installation

Install a domain by appending the root-level domain directory to the repository name:

npx skills add oracle/skills/db
npx skills add oracle/skills/graal
...

Repository Goals

Provide Oracle-wide skills in one repository.
Define domain entry points that help developers and agents route to the right topic quickly.
Keep each skill practical, source-backed, and easy to consume on demand.
Allow each domain to evolve its own taxonomy without breaking repo-wide consistency.

Domains

db/ is the active Oracle Database domain and includes database, ORDS, SQLcl, framework, container, and agent workflow skills.
oci/ is the root for future Oracle Cloud Infrastructure skills.
fusion/ is the root for future Oracle Fusion skills.
apex/ is the root for future Oracle APEX skills.
graal/ contains GraalVM skills, starting with Native Image.

Start Here

Pick the domain closest to your task.
Install that domain skill.
Add other domain skills only when needed.

Repository Layout

.
├── db/
│   ├── SKILL.md
│   ├── admin/
│   ├── agent/
│   ├── appdev/
│   ├── architecture/
│   ├── containers/
│   ├── design/
│   ├── devops/
│   ├── features/
│   ├── frameworks/
│   ├── migrations/
│   ├── monitoring/
│   ├── ords/
│   ├── performance/
│   ├── plsql/
│   ├── security/
│   ├── sql-dev/
│   └── sqlcl/
├── fusion/
│   └── SKILL.md
├── apex/
│   └── SKILL.md
├── graal/
│   ├── SKILL.md
│   └── native-image/
│       ├── build-native-image.md
│       ├── native-build-tools.md
│       ├── reachability-metadata.md
│       └── troubleshooting.md
└── oci/
    └── SKILL.md

Each domain has its own SKILL.md and any supporting index files it needs.

For a real domain, organize content by category directories and use SKILL.md as the table of contents. A domain SKILL.md should normally include:

## How to Use This Domain
## Directory Structure
## Category Routing
## Key Starting Points
## Common Multi-Step Flows

For stub domains, keep SKILL.md minimal and point users back to this README.md and SKILL_AUTHORING_GUIDE.md.

Version Coverage Standard

Skills that include version-specific behavior must include a section named ## Oracle Version Notes (19c vs 26ai).
Use Oracle Database 19c as the baseline compatibility target unless stated otherwise.
Explicitly call out features that require newer releases and provide 19c-compatible alternatives where practical.

poloclub/transformer-explainer

Transformer Explained Visually: Learn How LLM Transformer Models Work with Interactive Visualization

Transformer Explainer: Interactive Learning of Text-Generative Models

Transformer Explainer is an interactive visualization tool designed to help anyone learn how Transformer-based models like GPT work. It runs a live GPT-2 model right in your browser, allowing you to experiment with your own text and observe in real time how internal components and operations of the Transformer work together to predict the next tokens. Try Transformer Explainer at http://poloclub.github.io/transformer-explainer and watch a demo video on YouTube https://youtu.be/TFUc41G2ikY.

Live Demo

Try Transformer Explainer: http://poloclub.github.io/transformer-explainer

Research Paper

Transformer Explainer: Interactive Learning of Text-Generative Models. Aeree Cho, Grace C. Kim, Alexander Karpekov, Alec Helbling, Zijie J. Wang, Seongmin Lee, Benjamin Hoover, Duen Horng Chau. Poster, IEEE VIS 2024.

How to run locally

Prerequisites

Node.js v20 or higher
NPM v10 or higher

Steps

git clone https://github.com/poloclub/transformer-explainer.git
cd transformer-explainer
npm install
npm run dev

Then, on your web browser, access http://localhost:5173.

Credits

Transformer Explainer was created by Aeree Cho, Grace C. Kim, Alexander Karpekov, Alec Helbling, Jay Wang, Seongmin Lee, Benjamin Hoover, and Polo Chau at the Georgia Institute of Technology.

Citation

@article{cho2024transformer,
  title = {Transformer Explainer: Interactive Learning of Text-Generative Models},
  shorttitle = {Transformer Explainer},
  author = {Cho, Aeree and Kim, Grace C. and Karpekov, Alexander and Helbling, Alec and Wang, Zijie J. and Lee, Seongmin and Hoover, Benjamin and Chau, Duen Horng},
  journal={IEEE VIS Poster},
  year={2024}
}

License

The software is available under the MIT License.

Contact

If you have any questions, feel free to open an issue or contact Aeree Cho or any of the contributors listed above.

More AI explainers to check out

Diffusion Explainer for learning how Stable Diffusion transforms text prompt into image
CNN Explainer
GAN Lab for playing with Generative Adversarial Networks in browser

gaotianliuyun/gao

FongMi影视和tvbox配置文件，如果喜欢，请Fork自用。使用前请仔细阅读仓库说明，一旦使用将被视为你已了解。

FongMi影视、TVBox、猫影视配置文件。所有资源均来自于各路大神无私分享，如有侵权，请联系删除。

所有以任何方式查看本仓库内容的人、或直接或间接使用本仓库内容的使用者都应仔细阅读此声明。本仓库管理者保留随时更改或补充此免责声明的权利。一旦使用、复制、修改了本仓库内容，则视为您已接受此免责声明。

本仓库管理者不能保证本仓库内容的合法性、准确性、完整性和有效性，请根据情况自行判断。本仓库内容，仅用于测试和学习研究，禁止用于商业用途，不得将其用于违反国家、地区、组织等的法律法规或相关规定的其他用途，禁止任何公众号、自媒体进行任何形式的转载、发布，请不要在中华人民共和国境内使用本仓库内容，否则后果自负。

本仓库内容中涉及的第三方硬件、软件等，与本仓库内容没有任何直接或间接的关系。本仓库内容仅对部署和使用过程进行客观描述，不代表支持使用任何第三方硬件、软件。使用任何第三方硬件、软件，所造成的一切后果由使用的个人或组织承担，与本仓库内容无关。

所有直接或间接使用本仓库内容的个人和组织，应 24 小时内完成学习和研究，并及时删除本仓库内容。如对本仓库内容的功能有需求，应自行开发相关功能。所有基于本仓库内容的源代码，进行的任何修改，为其他个人或组织的自发行为，与本仓库内容没有任何直接或间接的关系，所造成的一切后果亦与本仓库内容和本仓库管理者无关。

tvbox配置：

（1）0707.json Fengmi影视多线配置接口,仅适用于Fengmi影视；

（2）0821.json 在饭太硬配置的基础上添加了若干优质点播源、直播线路和解析；

（3）0825.json jar包来源于Panda Groove的jar，PG网盘的用法请看https://github.com/gaotianliuyun/gao/blob/gaotianliuyun-patch-1/README.md ；

（4）0826.json 完全来源于饭太硬的jar包和配置；

（5）0827.json jar包和配置来源于fongmi；

（6）js.json jar包来源于Panda Groove的go包，资源来源于道长drpy(js)仓库；

（7）XYQ.json XYQ源，jar包和配置来源于香雅情；

（8）/cat/js/config_open.json cat源，资源暂停更新，如果有能力的大佬愿意发电，请联系我。

APP推荐:

（1）FongMi版本项目地址：https://github.com/FongMi/TV 支持直播多线路、自动换源、直播倍速，手机投屏；

（2）q215613905版本项目地址：https://github.com/q215613905/TVBoxOS 支持直播回放；

（3）takagen99版本项目地址：https://github.com/takagen99/Box 支持直播回放，界面美观；

（4）猫影视项目地址：https://github.com/catvod/CatVodOpen 界面简洁，支持多平台。

TVBox各路大佬配置（排名不分先后）：

（1）饭太硬：http://www.饭太硬.top/tv/

（2）okjack：https://jihulab.com/okcaptain/kko/raw/main/ok.txt

（3）王二小放牛娃：http://tvbox.王二小放牛娃.xyz

（4）摸鱼儿：http://我不是.摸鱼儿.top

（5）霜辉月明py：https://999740.xyz/raw.githubusercontent.com/lm317379829/PyramidStore/pyramid/py.json

（6）小米小爆脾气：http://xhww.fun/小米/DEMO.json

（7）南风：https://agit.ai/Yoursmile7/TVBox/raw/branch/master/XC.json

（8）神器：https://神器每日推送.tk/pz.json

（9）巧技：http://pandown.pro/tvbox/tvbox.json

（10）Ray：https://100km.top/0

（11）俊于：http://home.jundie.top:81/top98.json

随机轮换壁纸：

（1）https://jianbian.chuqiuyu.workers.dev 自制极简渐变壁纸

（2）http://www.kf666888.cn/api/tvbox/img

（3）https://picsum.photos/1280/720/?blur=10

（4）http://刚刚.live/图

（5）http://饭.eu.org/深色壁纸/api.php,

（6）https://www.dmoe.cc/random.php

（7）https://api.btstu.cn/sjbz/zsy.php

（8）https://api.btstu.cn/sjbz/?lx=dongman

（9）http://api.btstu.cn/sjbz/?lx=meizi

（10）http://api.btstu.cn/sjbz/?lx=suiji

（11）https://pictures.catvod.eu.org/

（12）https://bing.img.run/rand.php

自用仓库，如果喜欢，请Fork自用，谢谢！

尽自己所能更新，不保证配置的有效性和时效性。

juliangarnier/anime

JavaScript animation engine

Anime.js

Anime.js is a fast, multipurpose and lightweight JavaScript animation library with a simple, yet powerful API.
It works with CSS properties, SVG, DOM attributes and JavaScript Objects.

Usage

Anime.js V4 works by importing ES modules like so:

import {
  animate,
  stagger,
} from 'animejs';

animate('.square', {
  x: 320,
  rotate: { from: -180 },
  duration: 1250,
  delay: stagger(65, { from: 'center' }),
  ease: 'inOutQuint',
  loop: true,
  alternate: true
});

V4 Documentation

The full documentation is available here.

V3 Migration guide

You can find the v3 to v4 migration guide here.

NPM development scripts

First, run npm i to install all the necessary packages. Then, execute the following scripts with npm run <script>.

script	action
`dev`	Watches for changes in `src/*/.js`, bundles the ESM version to `lib/` and creates type declarations in `types/`
`dev:test`	Runs `dev` and `test:browser` concurrently
`build`	Bundles ESM / UMD / CJS / IIFE versions to `lib/` and creates type declarations in `types/`
`test:browser`	Starts a local server and runs all browser-related tests
`test:node`	Starts Node-related tests
`open:examples`	Starts a local server to browse the examples locally

atlassian/atlassian-mcp-server

Remote MCP Server that securely connects Jira and Confluence with your LLM, IDE, or agent platform of choice.

Atlassian MCP Server

The Atlassian Rovo MCP Server is a cloud-based bridge between your Atlassian Cloud site and compatible external tools. Once configured, it enables those tools to interact with Jira, Compass, and Confluence data in real-time. This functionality is powered by secure authentication using OAuth 2.1 or API tokens, which ensures all actions respect the user's existing access controls.

With the Atlassian Rovo MCP Server, you can:

Summarize and search Jira, Compass, and Confluence content without switching tools.
Create and update issues or pages based on natural language commands.
Automate repetitive work, like generating tickets from meeting notes or specs.

It's designed developers, content creators, and project teams who use IDEs or AI platforms and want to work with Atlassian data without constantly context switching.

Supported clients

The Atlassian Rovo MCP Server supports several clients, including:

The Atlassian Rovo MCP Server also supports any local MCP-compatible client that can run on localhost and connect to the server via the mcp-remote proxy. This enables custom or third-party integrations that follow the MCP specification.

For detailed setup instructions, refer to your client's own MCP documentation or built-in assistant.

Before you start

Ensure your environment meets the necessary requirements to successfully set up the Atlassian Rovo MCP Server. This section outlines the technical prerequisites and key access considerations.

Prerequisites

Before connecting to the Atlassian Rovo MCP Server, review the setup requirements for your environment:

For supported clients

An Atlassian Cloud site with Jira, Compass, and/or Confluence
Access to the client of choice
A modern browser to complete the OAuth 2.1 authorization flow, or API token credentials for headless authentication

For IDEs or local clients (Desktop setup)

An Atlassian Cloud site with Jira, Compass, and/or Confluence
A supported IDE (for example, Claude desktop, VS Code, or Cursor) or a custom MCP-compatible client
Node.js v18+ installed to run the local MCP proxy (mcp-remote)
A modern browser for completing OAuth login, or API token credentials for headless authentication

Data and security

Security is a core focus of the Atlassian Rovo MCP Server:

All traffic is encrypted via HTTPS using TLS 1.2 or later.
OAuth 2.1 and API token authentication provide secure access control.
Data access respects Jira, Compass, and Confluence user permissions.
If your organization uses IP allowlisting for Atlassian Cloud products, tool calls made through the Atlassian Rovo MCP Server also honor those IP rules.

For a deeper overview of the security model and admin controls, see:

How it works

Architecture and communication

A supported client connects to the server endpoint:

https://mcp.atlassian.com/v1/mcp

Depending on your setup, a secure browser-based OAuth 2.1 flow is triggered, or API token authentication is used.
Once authorized, the client streams contextual data and receives real-time responses from Jira, Compass, or Confluence.

Note

While /sse as a server endpoint are supported, we recommend updating any custom clients configured to use /sse so they now point to /mcp.

Permission management

Access is granted only to data that the user already has permission to view in Atlassian Cloud. All actions respect existing project or space-level roles. OAuth and API token authentication both honor configured scopes and Atlassian permissions.

API token authentication (headless)

API token authentication is available for headless or long-running client setups.

Admin enablement required: An organization admin must enable API token authentication for Rovo MCP Server.
Scoped token required: Use a Rovo MCP scoped API token for the required tools and data access.
Configuration guide: Configure authentication via API token
Admin setting reference: Control Atlassian Rovo MCP Server settings - Configure authentication

Example workflows

Once connected, you can perform a variety of useful tasks from within your supported client.

Jira workflows

Search: "Find all open bugs in Project Alpha."
Create/update: "Create a story titled 'Redesign onboarding'."
Bulk create: "Make five Jira issues from these notes."

Confluence workflows

Summarize: "Summarize the Q2 planning page."
Create: "Create a page titled 'Team Goals Q3'."
Navigate: "What spaces do I have access to?"

Compass workflows

Create: "Create a service component based on the current repository."
Bulk create: "Import components and custom fields from this CSV/JSON"
Query: "What depends on the api-gateway service?"

Combined tasks

Link content: "Link these three Jira tickets to the 'Release Plan' page."
Find documentation: "Fetch the Confluence documentation page linked to this Compass component."

Note

Actual capabilities vary, depending on your permission level and client platform.

Tips and tricks

Set default CloudId, Jira project, and Confluence space

Update your AGENTS.md with the Markdown below to reduce discovery tool calls, save time and tokens, and set maximum search results.

## Atlassian Rovo MCP

When connected to atlassian-rovo-mcp:
- **MUST** use Jira project key = YOURPROJ
- **MUST** use Confluence spaceId = "123456"
- **MUST** use cloudId = "https://yoursite.atlassian.net" (do NOT call getAccessibleAtlassianResources)
- **MUST** use `maxResults: 10` or `limit: 10` for ALL Jira JQL and Confluence CQL search operations.

Use skills

If you're using a desktop client like Claude, you can create or reuse skills for repeated tasks. See the default Rovo MCP skills

For Cursor, skills are part of the marketplace plugin.

Admin notes: Managing access

If you're an admin preparing your organization to use the Atlassian Rovo MCP Server, review these key considerations. For more detailed admin guidance, see:

Installation and access

Not a Marketplace App:
The Atlassian Rovo MCP Server is not installed via the Atlassian Marketplace or the Manage apps screen. Instead, it is installed automatically the first time a user completes the OAuth 2.1 (3LO) consent flow (just-in-time or "lazy loading" installation).
First-time installation requirements:
The first user to complete the 3LO consent flow for your site must have access to the Atlassian apps requested by the MCP scopes (for example, Jira and/or Confluence). This ensures the MCP app is registered with the correct permissions for your site.
Subsequent user access:
After the initial install, users with access to only one Atlassian app (for example, just Jira or just Confluence) can also complete the 3LO flow to access that Atlassian app through MCP.

Manage, monitor, and revoke access

Admin controls:
Site and organization admins can manage, review, or revoke the MCP app's access from Manage your organization's Marketplace and third-party apps. The app appears in your site's Connected apps list after the first successful 3LO consent.
End-user controls:
Individual users can revoke their own app authorizations from their profile settings.
Domain and IP controls:
Use the Rovo MCP server settings page in Atlassian Administration to control which external AI tools and domains are allowed to connect. For details, see Available Atlassian Rovo MCP server domains. If your organization uses IP allowlisting for Atlassian Cloud apps, requests made through the Atlassian Rovo MCP Server must originate from an IP address that is allowed by your organization's IP allowlist for the relevant Atlassian app. For configuration details, see Specify IP addresses for app access.
Audit logging: To support monitoring and compliance, key actions performed via the Atlassian Rovo MCP Server are logged in your organization's audit log. Admins can review these logs in Atlassian Administration. For more information, see Monitor Atlassian Rovo MCP server activity.

Troubleshooting common issues

"Your site admin must authorize this app" error:
A site admin must complete the 3LO consent flow before anyone else can use the MCP app. See "Your site admin must authorize this app" error in Atlassian Cloud apps for more details.
"You don't have permission to connect from this IP address. Please ask your admin for access."
This usually indicates that IP allowlisting is enabled and the user's current IP address isn't allowed to access Jira, Confluence, Compass, or Rovo via the Atlassian Rovo MCP Server. Ask your site or organization admin to review the IP allowlist configuration and add the relevant network or VPN IP ranges if appropriate.
App not appearing in Connected apps:
Ensure the user is using the correct Atlassian account and site, and confirm the app is requesting the correct Atlassian app scopes (for example, Jira scopes). If issues persist, check Manage your organization's Marketplace and third-party apps or contact Atlassian Support. Also verify the user's Jira, Confluence, or Compass permissions in Atlassian Administration.

Security

Model Context Protocol (MCP) lets AI agents connect to tools and Atlassian data using your account’s permissions, which creates powerful workflows but also structural risks. Any MCP client or server you enable (e.g., IDE plugins, desktop apps, hosted MCP servers, “one-click” integrations) can cause an AI agent to perform actions on your behalf.

Large Language models (LLMs) are vulnerable to prompt injection and related attacks (such as indirect prompt injection and tool poisoning). These attacks can instruct the agent to exfiltrate data or make unintended changes without explicit requests.

To reduce risk, only use trusted MCP clients and servers, carefully review which tools and data each agent can access, and apply least privilege (scoped tokens, minimal project/workspace access). For any high‑impact or destructive action, require human confirmation and monitor audit logs for unusual activity. We strongly recommend reviewing Atlassian’s guidance on MCP risks at MCP Clients: Understanding the potential security risks

Support and feedback

Your feedback plays a crucial role in shaping the Atlassian Rovo MCP Server. If you encounter bugs, limitations, or have suggestions:

Visit the Atlassian Support Portal Portal to report issues and feature requests.
Share your experiences and questions on the Atlassian Community and developer-related asks on the Developer's one.
Go to our Ecosystem Developer Portal if you are building an app and found a bug/issue or have suggestions.

Disclaimer

MCP clients can perform actions in Jira, Confluence, and Compass with your existing permissions. Use least privilege, review high‑impact changes before confirming, and monitor audit logs for unusual activity.

Learn more: MCP Clients - (Understanding the potential security risks)[https://www.atlassian.com/blog/artificial-intelligence/mcp-risk-awareness]

ykdojo/claude-code-tips

45 tips for getting the most out of Claude Code, from basics to advanced - includes a custom status line script, cutting the system prompt in half, using Gemini CLI as Claude Code's minion, and Claude Code running itself in a container. Also includes the dx plugin.

45 Claude Code Tips: From Basics to Advanced

Here are my tips for getting the most out of Claude Code, including a custom status line script, cutting the system prompt in half, using Gemini CLI as Claude Code's minion, and Claude Code running itself in a container. Also includes the dx plugin.

📺 Quick demo - See some of these tips in action with a multi-Claude workflow and voice input:

Tip 0: Customize your status line

You can customize the status line at the bottom of Claude Code to show useful info. I set mine up to show the model, current directory, git branch (if any), uncommitted file count, sync status with origin, and a visual progress bar for token usage. It also shows a second line with my last message so I can see what the conversation was about:

Opus 4.5 | 📁claude-code-tips | 🔀main (scripts/context-bar.sh uncommitted, synced 12m ago) | ██░░░░░░░░ 18% of 200k tokens
💬 This is good. I don't think we need to change the documentation as long as we don't say that the default color is orange el...

This is especially helpful for keeping an eye on your context usage and remembering what you were working on. The script also supports 10 color themes (orange, blue, teal, green, lavender, rose, gold, slate, cyan, or gray).

To set this up, you can use this sample script and check the setup instructions.

Tip 1: Learn a few essential slash commands

There are a bunch of built-in slash commands (type / to see them all). Here are a few worth knowing:

/usage

Check your rate limits:

 Current session
 █████████▌                                         19% used
 Resets 12:59am (America/Vancouver)

 Current week (all models)
 █████████████████████▌                             43% used
 Resets Feb 3 at 1:59pm (America/Vancouver)

 Current week (Sonnet only)
 ███████████████████▌                               39% used
 Resets 8:59am (America/Vancouver)

If you want to watch your usage closely, keep it open in a tab and use Tab then Shift+Tab or ← then → to refresh.

/chrome

Toggle Claude's native browser integration:

> /chrome
Chrome integration enabled

/mcp

Manage MCP (Model Context Protocol) servers:

 Manage MCP servers
 1 server

 ❯ 1. playwright  ✔ connected · Enter to view details

 MCP Config locations (by scope):
  • User config (available in all your projects):
    • /Users/yk/.claude.json

/stats

View your usage statistics with a GitHub-style activity graph:

      Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec Jan
      ··········································▒█░▓░█░▓▒▒
  Mon ·········································▒▒██▓░█▓█░█
      ·········································░▒█▒▓░█▒█▒█
  Wed ········································░▓▒█▓▓░▒▓▒██
      ········································░▓░█▓▓▓▓█░▒█
  Fri ········································▒░░▓▒▒█▓▓▓█
      ········································▒▒░▓░░▓▒▒░░

      Less ░ ▒ ▓ █ More

  Favorite model: Opus 4.5        Total tokens: 17.6m

  Sessions: 4.1k                  Longest session: 20h 40m 45s
  Active days: 79/80              Longest streak: 75 days
  Most active day: Jan 26         Current streak: 74 days

  You've used ~24x more tokens than War and Peace

/clear

Clear the conversation and start fresh.

Tip 2: Talk to Claude Code with your voice

I found that you can communicate much faster with your voice than typing with your hands. Using a voice transcription system on your local machine is really helpful for this.

On my Mac, I've tried a few different options:

superwhisper
MacWhisper
Super Voice Assistant (open source, supports Parakeet v2/v3)

You can get more accuracy by using a hosted service, but I found that a local model is strong enough for this purpose. Even when there are mistakes or typos in the transcription, Claude is smart enough to understand what you're trying to say. Sometimes you need to say certain things extra clearly, but overall local models work well enough.

For example, in this screenshot you can see that Claude was able to interpret mistranscribed words like "ExcelElanishMark" and "advast" correctly as "exclamation mark" and "Advanced":

I think the best way to think about this is like you're trying to communicate with your friend. Of course, you can communicate through texts. That might be easier for some people, or emails, right? That's totally fine. That's what most people seem to do with Claude Code. But if you want to communicate faster, why wouldn't you get on a quick phone call? You can just send voice messages. You don't need to literally have a phone call with Claude Code. Just send a bunch of voice messages. It's faster, at least for me, as someone who's practiced the art of speaking a lot over the past number of years. But I think for a majority of people, it's going to be faster too.

A common objection is "what if you're in a room with other people?" I just whisper using earphones - I personally like Apple EarPods (not AirPods). They're affordable, high quality enough, and you just whisper into them quietly. I've done it in front of other people and it works well. In offices, people talk anyway - instead of talking to coworkers, you're talking quietly to your voice transcription system. I don't think there's any problem with that. This method works so well that it even works on a plane. It's loud enough that other people won't hear you, but if you speak close enough to the mic, your local model can still understand what you're saying. (In fact, I'm writing this very paragraph using that method on a flight.)

Update: Claude Code now has a built-in voice mode. I tested it and it works well, but I still personally use a local model because I find it faster.

Tip 3: Break down large problems into smaller ones

This is one of the most important concepts to master. It's exactly the same as traditional software engineering - the best software engineers already know how to do this, and it applies to Claude Code too.

If you find that Claude Code isn't able to one-shot a difficult problem or coding task, ask it to break it down into multiple smaller issues. See if it can solve an individual part of that problem. If it's still too hard, see if it can solve an even smaller sub-problem. Keep going until everything is solvable.

Essentially, instead of going from A to B:

You can go from A to A1 to A2 to A3, then to B:

A good example of this is when I was building my own voice transcription system. I needed to build a system that could let the user select and download a model, take keyboard shortcuts, start transcribing, put the transcribed text at the user's cursor, and wrap all of this in a nice UI. That's a lot. So I broke it down into smaller tasks. First, I created an executable that would just download a model, nothing else. Then I created another one that would just record voice, nothing else. Then another one that would just transcribe pre-recorded audio. I completed them one by one like that before combining them at the end.

Highly related to this: your problem-solving skills and software engineering skills are still highly relevant in the world of agentic coding and Claude Code. It's able to solve a lot of problems on its own, but when you apply your general problem-solving and software engineering skills to it, it becomes a lot more powerful.

Tip 4: Using Git and GitHub CLI like a pro

Just ask Claude to handle your Git and GitHub CLI tasks. This includes committing (so you don't have to write commit messages manually), branching, pulling, and pushing.

I personally allow pull automatically but not push, because push is riskier - it doesn't contaminate the origin if something goes wrong with a pull.

For GitHub CLI (gh), there's a lot you can do. One thing I started doing more after using Claude Code is creating draft PRs. This lets Claude Code handle the PR creation process with low risk - you can review everything before marking it ready for review.

And it turns out, gh is pretty powerful. You can even send arbitrary GraphQL queries through it. For example, you can even find the exact times at which GitHub PR descriptions were edited:

⏺ Bash(gh api graphql -f query='
      query {
        repository(owner: "...", name: "...") {
          pullRequest(number: ...) {
            userContentEdits(first: 100) {
              nodes { editedAt editor { login } }
            }
          }
        }
      }')

⏺ Here's the full edit history for your PR description:

  | #  | Edited At (UTC)     | Editor |
  |----|---------------------|--------|
  | 1  | 2025-12-01 00:08:34 | ykdojo |
  | 2  | 2025-12-01 15:57:21 | ykdojo |
  | 3  | 2025-12-01 16:24:33 | ykdojo |
  | 4  | 2025-12-01 16:27:00 | ykdojo |
  | 5  | 2025-12-04 00:40:02 | ykdojo |
  ...

Disable commit/PR attribution

By default, Claude Code adds a Co-Authored-By trailer to commits and an attribution footer to PRs. You can disable both by adding this to ~/.claude/settings.json:

{
  "attribution": {
    "commit": "",
    "pr": ""
  }
}

Setting both to empty strings removes the attribution entirely. This replaces the older includeCoAuthoredBy setting, which is now deprecated.

Tip 5: AI context is like milk; it's best served fresh and condensed!

When you start a new conversation with Claude Code, it performs the best because it doesn't have all the added complexity of having to process the previous context from earlier parts of the conversation. But as you talk to it longer and longer, the context gets longer and the performance tends to go down.

So it's best to start a new conversation for every new topic, or if the performance starts to go down.

Tip 6: Getting output out of your terminal

Sometimes you want to copy and paste Claude Code's output, but copying directly from the terminal isn't always clean. Here are a few ways to get content out more easily:

/copy command: The simplest option - just type /copy to copy Claude's last response to your clipboard as markdown
Clipboard directly: On Mac or Linux, ask Claude to use pbcopy to send output straight to your clipboard
Write to a file: Have Claude put the content in a file, then ask it to open it in VS Code (or your favorite editor) so you can copy from there. You can also specify a line number, so you can ask Claude to open the specific line it just edited. For markdown files, once it's open in VS Code, you can use Cmd+Shift+P (or Ctrl+Shift+P on Linux/Windows) and select "Markdown: Open Preview" to see the rendered version
Opening URLs: If there's a URL you want to examine yourself, ask Claude to open it in your browser. On Mac, you can ask it to use the open command, but in general asking to open in your favorite browser should work on any platform
GitHub Desktop: You can ask Claude to open the current repo in GitHub Desktop. This is particularly useful when it's working in a non-root directory - for example, if you asked it to create a git worktree in a different directory and you haven't opened Claude Code from there yet

You can combine some of these together too. For example, if you want to edit a GitHub PR description, instead of having Claude edit it directly (which it might mess up), you can have it copy the content into a local file first. Let it edit that, check the result yourself, and once it looks good, have it copy and paste it back into the GitHub PR. That works really well. Or if you want to do that yourself, you can just ask it to open it in VS Code or give it to you via pbcopy so you can copy and paste it manually.

Of course, you can run these commands yourself, but if you find yourself doing it repetitively, it's helpful to let Claude run them for you.

Tip 7: Set up terminal aliases for quick access

Since I use the terminal more because of Claude Code, I found it helpful to set up short aliases so I can launch things quickly. Here are the ones I use:

c for Claude Code (this is the one I use the most)
ch for Claude Code with Chrome integration
gb for GitHub Desktop
co for VS Code
q for going to the project directory where I have most projects. From there I can manually cd into an individual folder to work on that project, or I can just launch Claude Code with c to let it basically have access to any project it needs to access.

To set these up, add lines like this to your shell config file (~/.zshrc or ~/.bashrc):

alias c='claude'
alias ch='claude --chrome'
alias gb='github'
alias co='code'
alias q='cd ~/Desktop/projects'

Once you have these aliases, you can combine them with flags: c -c continues your last conversation, and c -r shows a list of recent conversations to resume. These work with ch too (ch -c, ch -r) for Chrome sessions.

Tip 8: Proactively compact your context

There's a /compact command in Claude Code that summarizes your conversation to free up context space. Automatic compaction also happens when the full available context is filled. The total available context window for Opus 4.5 is currently 200k, and 45k of that is reserved for automatic compaction. About 10% of the total 200k is automatically filled with the system prompt, tools, memory, and dynamic context. But I found that it's better to proactively do it and manually tune it. I turned off auto-compact with /config so I have more context available for the main conversation and more control over when and how compaction happens.

The way I do this is to ask Claude to write a handoff document before starting fresh. Something like:

Put the rest of the plan in the system-prompt-extraction folder as HANDOFF.md. Explain what you have tried, what worked, what didn't work, so that the next agent with fresh context is able to just load that file and nothing else to get started on this task and finish it up.

Claude will create a file summarizing the current state of work:

⏺ Write(experiments/system-prompt-extraction/HANDOFF.md)
  ⎿  Wrote 129 lines to experiments/system-prompt-extraction/HANDOFF.md
     # System Prompt Slimming - Handoff Document
     ## Goal
     Reduce Claude Code's system prompt by ~45% (currently at 11%, need ~34% more).
     ## Current Progress
     ### What's Been Done
     - **Backup/restore system**: `backup-cli.sh` and `restore-cli.sh` with SHA256 verification
     - **Patch system**: `patch-cli.js` that restores from backup then applies patches
     ...

After Claude writes it, review it quickly. If something's missing, ask for edits:

Did you add a note about iteratively testing instead of trying to do everything all at once?

Then start a fresh conversation. For the fresh agent, you can just give the path of the file and nothing else like this, and it should work just fine:

> experiments/system-prompt-extraction/HANDOFF.md

In subsequent conversations, you can ask the agent to update the document for the next agent.

I've also created a /handoff slash command that automates this - it checks for an existing HANDOFF.md, reads it if present, then creates or updates it with the goal, progress, what worked, what didn't, and next steps. You can find it in the skills folder, or install it via the dx plugin.

Alternative: Use plan mode

Another option is to use plan mode. Enter it with /plan or Shift+Tab. Ask Claude to gather all the relevant context and create a comprehensive plan for the next agent:

I just enabled plan mode. Bring over all of the context that you need for the next agent. The next agent will not have any other context, so you'll need to be pretty comprehensive.

Claude will explore the codebase, gather context, and write a detailed plan. When it's done, you'll see options like:

Would you like to proceed?

❯ 1. Yes, clear context and auto-accept edits (shift+tab)
  2. Yes, auto-accept edits
  3. Yes, manually approve edits
  4. Type here to tell Claude what to change

Option 1 clears the previous context and starts fresh with the plan. The new Claude instance sees only the plan, so it can focus without the baggage of the old conversation. It also gets a link to the old transcript file in case it needs to look up specific details.

Tip 9: Complete the write-test cycle for autonomous tasks

If you want Claude Code to run something autonomously, like git bisect, you need to give it a way to verify results. The key is completing the write-test cycle: write code, run it, check the output, and repeat.

For example, let's say you're working on Claude Code itself and you notice /compact stopped working and started throwing a 400 error. A classic tool to find the exact commit that caused this is git bisect. The nice thing is you can let Claude Code run bisect on itself, but it needs a way to test each commit.

For tasks that involve interactive terminals like Claude Code, you can use tmux. The pattern is:

Start a tmux session
Send commands to it
Capture the output
Verify it's what you expect

Here's a simple example of testing if /context works:

tmux kill-session -t test-session 2>/dev/null
tmux new-session -d -s test-session
tmux send-keys -t test-session 'claude' Enter
sleep 2
tmux send-keys -t test-session '/context' Enter
sleep 1
tmux capture-pane -t test-session -p

Once you have a test like this, Claude Code can run git bisect and automatically test each commit until it finds the one that broke things.

This is also an example of why your software engineering skills still matter. If you're a software engineer, you probably know about tools like git bisect. That knowledge is still really valuable when working with AI - you just apply it in new ways.

Another example is simply writing tests. After you let Claude Code write some code, if you want to test it, you can just let it write tests for itself too. And let it run on its own and fix things if it can. Of course, it doesn't always go in the right direction and you need to supervise it sometimes, but it's able to do a surprising amount of coding tasks on its own.

Creative testing strategies

Sometimes you need to be creative with how you complete the write-test cycle. For example, if you're building a web app, you could use Playwright MCP, Chrome DevTools MCP, or Claude's native browser integration (through /chrome). I haven't tried Chrome DevTools yet, but I've tried Playwright and Claude's native integration. Overall, Playwright generally works better. It does use a lot of context, but the 200k context window is normally enough for a single task or a few smaller tasks.

The main difference between these two seems to be that Playwright focuses on the accessibility tree (structured data about page elements) rather than taking screenshots. It does have the ability to take screenshots, but it doesn't normally use them to take actions. On the other hand, Claude's native browser integration focuses more on taking screenshots and clicking on elements by specific coordinates. It can click on random things sometimes, and the whole process can be slow.

This might improve over time, but by default I would go with Playwright for most tasks that aren't visually intensive. I'd only use Claude's native browser integration if I need to use a logged-in state without having to provide credentials (since it runs in your own browser profile), or if it specifically needs to click on things visually using their coordinates.

This is why I disable Claude's native browser integration by default and use it through the ch shortcut I defined previously. That way Playwright handles most browser tasks, and I only enable Claude's native integration when I specifically need it.

Additionally, you can ask it to use accessibility tree refs instead of coordinates. Here's what I put in my CLAUDE.md for this:

# Claude for Chrome

- Use `read_page` to get element refs from the accessibility tree
- Use `find` to locate elements by description
- Click/interact using `ref`, not coordinates
- NEVER take screenshots unless explicitly requested by the user

In my personal experience, I've also had a situation where I was working on a Python library (Daft) and needed to test a version I built locally on Google Colab. The trouble is it's hard to build a Python library with a Rust backend on Google Colab - it doesn't seem to work that well. So I needed to actually build a wheel locally and then upload it manually so that I could run it on Google Colab. I also tried monkey patching, which worked well in the short term before I had to wait for the whole wheel to build locally. I came up with these testing strategies and executed them by going back and forth with Claude Code.

Another situation I encountered is I needed to test something on Windows but I'm not running a Windows machine. My CI tests on the same repo were failing because we had some issues with Rust on Windows, and I had no way of testing locally. So I needed to create a draft PR with all the changes, and another draft PR with the same changes plus enabling Windows CI runs on non-main branches. I instructed Claude Code to do all of that, and then I tested the CI directly in that new branch.

Tip 10: Cmd+A and Ctrl+A are your friends

I've been saying this for a few years now: Cmd+A and Ctrl+A are friends in the world of AI. This applies to Claude Code too.

Sometimes you want to give Claude Code a URL, but it can't access it directly. Maybe it's a private page (not sensitive data, just not publicly accessible), or something like a Reddit post that Claude Code has trouble fetching. In those cases, you can just select all the content you see (Cmd+A on Mac, Ctrl+A on other platforms), copy it, and paste it directly into Claude Code. It's a pretty powerful method.

This works great for terminal output too. When I have output from Claude Code itself or any other CLI application, I can use the same trick: select all, copy, and paste it back to CC. Pretty helpful.

Some pages don't lend themselves well to select all by default - but there are tricks to get them into a better state first. For example, with Gmail threads, click Print All to get the print preview (but cancel the actual print). That page shows all emails in the thread expanded, so you can Cmd+A the entire conversation cleanly. For asking questions about a YouTube video or summarizing it, you can click "Show transcript" on a YouTube video and then do Cmd+A or Ctrl+A.

This applies to any AI, not just Claude Code.

Tip 11: Use Gemini CLI as a fallback for blocked sites

Claude Code's WebFetch tool can't access certain sites, like Reddit. But you can work around this by creating a skill that tells Claude to use Gemini CLI as a fallback. Gemini has web access and can fetch content from sites that Claude can't reach directly.

This uses the same tmux pattern from Tip 9 - start a session, send commands, capture output. The skill file goes in ~/.claude/skills/reddit-fetch/SKILL.md. See skills/reddit-fetch/SKILL.md for the full content.

Skills are more token-efficient because Claude Code only loads them when needed. If you want something simpler, you can put a condensed version in ~/.claude/CLAUDE.md instead, but that gets loaded into every conversation whether you need it or not.

I tested this by asking Claude Code to check how Claude Code skills are regarded on Reddit - a bit meta. It goes back and forth with Gemini for a while, so it's not fast, but the report quality was surprisingly good. Obviously, you'll need to have Gemini CLI installed for this to work. You can also install this skill via the dx plugin.

Tip 12: Invest in your own workflow

Personally, I've created my own voice transcription app from scratch with Swift. I created my own custom status line from scratch using Claude Code, this one with bash. And I created my own system for simplifying the system prompt in Claude Code's minified JavaScript file.

But you don't have to go overboard like that. Just taking care of your own CLAUDE.md, making sure it's as concise as possible while being able to help you achieve your goals - stuff like that is helpful. And of course, learning these tips, learning these tools, and some of the most important features.

All of these are investments in the tools you use to build whatever you want to build. I think it's important to spend at least a little bit of time on that.

Tip 13: Search through your conversation history

You can ask Claude Code about your past conversations, and it'll help you find and search through them. Your conversation history is stored locally in ~/.claude/projects/, with folder names based on the project path (slashes become dashes).

For example, conversations for a project at /Users/yk/Desktop/projects/claude-code-tips would be stored in:

~/.claude/projects/-Users-yk-Desktop-projects-claude-code-tips/

Each conversation is a .jsonl file. You can search through them with basic bash commands:

# Find all conversations mentioning "Reddit"
grep -l -i "reddit" ~/.claude/projects/-Users-yk-Desktop-projects-*/*.jsonl

# Find today's conversations about a topic
find ~/.claude/projects/-Users-yk-Desktop-projects-*/*.jsonl -mtime 0 -exec grep -l -i "keyword" {} \;

# Extract just the user messages from a conversation (requires jq)
cat ~/.claude/projects/.../conversation-id.jsonl | jq -r 'select(.type=="user") | .message.content'

Or just ask Claude Code directly: "What did we talk about regarding X today?" and it'll search through the history for you.

Tip 14: Multitasking with terminal tabs

When running multiple Claude Code instances, staying organized is more important than any specific technical setup like Git worktrees. I recommend focusing on at most three or four tasks at a time.

My personal method is what I would call a "cascade" - whenever I start a new task, I just open a new tab on the right. Then I sweep left to right, left to right, going from oldest tasks to newest. The general direction stays consistent, except when I need to check on certain tasks, get notifications, etc.

Here's what my setup typically looks like:

In this example:

Leftmost tab - A persistent tab running my voice transcription system (always stays here)
Second tab - Setting up a Docker container
Third tab - Checking disk usage on my local machine
Fourth tab - Working on an engineering project
Fifth tab (current) - Writing this very tip

Tip 15: Slim down the system prompt

Claude Code's system prompt and tool definitions take up about 19k tokens (~10% of your 200k context) before you even start working. I created a patch system that reduces this to about 9k tokens - saving around 10,000 tokens (~50% of the overhead).

Component	Before	After	Savings
System prompt	3.0k	1.8k	1,200 tokens
System tools	15.6k	7.4k	8,200 tokens
Total	~19k	~9k	~10k tokens (~50%)

Here's what /context looks like before and after patching:

Unpatched (~20k, 10%)

Patched (~10k, 5%)

The patches work by trimming verbose examples and redundant text from the minified CLI bundle while keeping all the essential instructions.

I've tested this extensively and it works well. It feels more raw - more powerful, but maybe a little less regulated, which makes sense because the system instruction is shorter. It feels more like a pro tool when you use it this way. I really enjoy starting with lower context because you have more room before it fills up, which gives you the option to continue conversations a bit longer. That's definitely the best part of this strategy.

Check out the system-prompt folder for the patch scripts and full details on what gets trimmed.

Why patching? Claude Code has flags that let you provide a simplified system prompt from a file (--system-prompt or --system-prompt-file), so that's another way to go about it. But for the tool descriptions, there's no official option to customize them. Patching the CLI bundle is the only way. Since my patch system handles everything in one unified approach, I'm keeping it this way for now. I might re-implement the system prompt portion using the flag in the future.

Supported installations: npm and native binary (macOS and Linux).

Important: If you want to keep your patched system prompt, disable auto-updates by adding this to ~/.claude/settings.json:

{
  "env": {
    "DISABLE_AUTOUPDATER": "1"
  }
}

This applies to all Claude Code sessions regardless of shell type (interactive, non-interactive, tmux). You can manually update later when you're ready to re-apply patches to a new version.

Lazy-load MCP tools

If you use MCP servers, their tool definitions are loaded into every conversation by default - even if you don't use them. This can add significant overhead, especially with multiple servers configured.

Enable lazy-loading so MCP tools are only loaded when needed:

{
  "env": {
    "ENABLE_TOOL_SEARCH": "true"
  }
}

Add this to ~/.claude/settings.json. Claude will search for and load MCP tools on-demand rather than having them all present from the start. As of version 2.1.7, this happens automatically when MCP tool descriptions exceed 10% of the context window.

Tip 16: Git worktrees for parallel branch work

If you're working on multiple things at the same time in the same project and you don't want them to get conflicted, Git worktrees are a great way to do that. You can just ask Claude Code to create a git worktree and start working on it there - you don't have to worry about the specific syntax.

The basic idea is that you can work on a different branch in a different directory. It's essentially a branch + a directory.

You can add this layer of Git worktrees on top of the cascade method I discussed in the multitasking tip.

What are git worktrees?

A git worktree is just like any other git branch, but with a new directory specifically assigned to it.

So if you're working on, let's say, the main branch and feature-branch-1, then without git worktrees, you can only work on them one at a time because your project folder can only be set to one branch at a time.

However, with a git worktree, you can keep working on the main branch (or any other branch for that matter) in the original project folder, and at the same time work on feature-branch-1 in a new folder.

Tip 17: Manual exponential backoff for long-running jobs

When waiting on long-running jobs like Docker builds or GitHub CI, you can ask Claude Code to do manual exponential backoff. Exponential backoff is a common technique in software engineering, but you can apply it here too. Ask Claude Code to check the status with increasing sleep intervals - one minute, then two minutes, then four minutes, and so on. It's not programmatically doing it in the traditional sense - the AI is doing it manually - but it works pretty well.

This way the agent can continuously check the status and let you know once it's done.

(For GitHub CI specifically, gh run watch exists but outputs many lines continuously, which wastes tokens. Manual exponential backoff with gh run view <run-id> | grep <job-name> is actually more token-efficient. This is also a general technique that works well even when you don't have a dedicated wait command handy.)

For example, if you have a Docker build running in the background:

And it keeps going until the job completes.

Tip 18: Claude Code as a writing assistant

Claude Code is an excellent writing assistant and partner. The way I use it for writing is I first give it all the context about what I'm trying to write, and then I give it detailed instructions by speaking to it using my voice. That gives me the first draft. If it's not good enough, I try a few times.

Then I go through it line by line, pretty much. I say okay, let's take a look at it together. I like this line for these reasons. I feel like this line needs to move over there. This line needs to change in this particular way. I might ask about reference materials as well.

So it's this sort of back-and-forth process, maybe with the terminal on the left and your code editor on the right:

That tends to work really well.

Tip 19: Markdown is the s**t

Typically when people write a new document, they might use something like Google Docs or maybe Notion. But now I honestly think the most efficient way to go about it is markdown.

Markdown was already pretty good even before AI, but with Claude Code in particular, because it's so efficient as I mentioned with regards to writing, it makes the value of markdown higher in my opinion. Whenever you want to write a blog post or even a LinkedIn post, you can just talk to Claude Code, have it be saved as markdown, and then go from there.

A quick tip for this one: if you want to copy and paste markdown content into a platform that doesn't accept it easily, you can paste it into a fresh Notion file first, then copy from Notion into the other platform. Notion converts it to a format that other platforms can accept. If regular pasting doesn't work, try Command + Shift + V to paste without formatting.

Tip 20: Use Notion to preserve links when pasting

It turns out the reverse also works. If you have text with links from other places, let's say from Slack, you can copy it. If you paste it directly into Claude Code, it doesn't show the links. But if you put it in a Notion document first, then copy from there, you get it in markdown, which of course Claude Code can read.

Tip 21: Containers for long-running risky tasks

Regular sessions are more for methodical work where you control the permissions you give and review output more carefully. Containerized environments are great for --dangerously-skip-permissions sessions where you don't have to give permission for each little thing. You can just let it run on its own for a while.

This is useful for research or experimentation, things that take a long time and maybe could be risky. A good example is the Reddit research workflow from Tip 11, where the reddit-fetch skill goes back and forth with Gemini CLI through tmux. Running that unsupervised is risky on your main system, but in a container, if something goes wrong, it's contained.

Another example is how I created the system prompt patching scripts in this repo. When a new version of Claude Code comes out, I need to update the patches for the minified CLI bundle. Instead of running Claude Code with --dangerously-skip-permissions on my host machine (where it has access to everything), I run it in a container. Claude Code can explore the minified JavaScript, find the variable mappings, and create new patch files without me approving every little thing that way.

In fact, it was able to complete the migration pretty much on its own. It tried applying the patches, found that some didn't work with the new version, iterated to fix them, and even improved the instruction document for future instances based on what it learned.

I even created SafeClaw to make running containerized Claude Code sessions easy. It lets you spin up multiple isolated sessions, each with a web terminal, and manage them all from a dashboard. It uses several customizations from this repo, including the optimized system prompt, DX plugin, and status line.

Advanced: Orchestrating a worker Claude Code in a container

You can take this further by having your local Claude Code control another Claude Code instance running inside a container. The trick is using tmux as the control layer:

Your local Claude Code starts a tmux session
In that tmux session, it runs or connects to the container
Inside the container, Claude Code runs with --dangerously-skip-permissions
Your outer Claude Code uses tmux send-keys to send prompts and capture-pane to read output

This gives you a fully autonomous "worker" Claude Code that can run experimental or long-running tasks without you approving every action. When it's done, your local Claude Code can pull the results back. If something goes wrong, it's all sandboxed in the container.

Advanced: Multi-model orchestration

Beyond just Claude Code, you can run different AI CLIs in containers - Codex, Gemini CLI, or others. I tried OpenAI Codex for code review, and it works well. The point isn't that you can't run these CLIs directly on your host machine - you obviously can. The value is that Claude Code's UI/UX is smooth enough that you can just talk to it and let it handle the orchestration: spinning up different models, sending data between containers and your host. Instead of manually switching between terminals and copy-pasting, Claude Code becomes the central interface that coordinates everything.

Tip 22: The best way to get better at using Claude Code is by using it

Recently I saw a world-class rock climber being interviewed by another rock climber. She was asked, "How do you get better at rock climbing?" She simply said, "By rock climbing."

That's how I feel about this too. Of course, there are supplementary things you can do, like watching videos, reading books, learning about tips. But using Claude Code is the best way to learn how to use it. Using AI in general is the best way to learn how to use AI.

I like to think of it like a billion token rule instead of the 10,000 hour rule. If you want to get better at AI and truly get a good intuition about how it works, the best way is to consume a lot of tokens. And nowadays it's possible. I found that especially with Opus 4.5, it's powerful enough but affordable enough that you can run multiple sessions at the same time. You don't have to worry as much about token usage, which frees you up a lot.

Tip 23: Clone/fork and half-clone conversations

Sometimes you want to try a different approach from a specific point in a conversation without losing your original thread. The clone-conversation script lets you duplicate a conversation with new UUIDs so you can branch off.

Built-in alternatives (recent versions): Claude Code now has native forking:

/fork - forks the current session from within a conversation
--fork-session - use with --resume or --continue (e.g., claude -c --fork-session)

Since --fork-session has no short form, you can add this function to your ~/.zshrc or ~/.bashrc to use --fs as a shortcut:

claude() {
  local args=()
  for arg in "$@"; do
    if [[ "$arg" == "--fs" ]]; then
      args+=("--fork-session")
    else
      args+=("$arg")
    fi
  done
  command claude "${args[@]}"
}

This intercepts all claude commands, expands --fs to --fork-session, and passes everything else through unchanged. Works with aliases too (see Tip 7): c -c --fs, ch -c --fs, etc.

The clone script below predates these built-in options, but the half-clone script below that remains unique for reducing context.

The first message is tagged with [CLONED <timestamp>] (e.g., [CLONED Jan 7 14:30]), which shows up both in the claude -r list and inside the conversation.

To set it up manually, symlink both files:

ln -s /path/to/this/repo/scripts/clone-conversation.sh ~/.claude/scripts/clone-conversation.sh
ln -s /path/to/this/repo/skills/clone ~/.claude/skills/clone

Or install via the dx plugin - no symlinks needed.

Then just type /clone (or /dx:clone if using the plugin) in any conversation and Claude will handle finding the session ID and running the script.

I've tested this extensively and the cloning works really well.

Half-clone to reduce context

When a conversation gets too long, the half-clone-conversation script keeps only the later half. This reduces token usage while preserving your recent work. The first message is tagged with [HALF-CLONE <timestamp>] (e.g., [HALF-CLONE Jan 7 14:30]).

To set it up manually, symlink both files:

ln -s /path/to/this/repo/scripts/half-clone-conversation.sh ~/.claude/scripts/half-clone-conversation.sh
ln -s /path/to/this/repo/skills/half-clone ~/.claude/skills/half-clone

Or install via the dx plugin - no symlinks needed.

Auto-suggest half-clone with a hook

Optionally, you can use a hook to automatically trigger /half-clone when your context gets too long. The check-context script runs after every Claude response and checks context usage. If it's over 85%, it tells Claude to run /half-clone, which creates a new conversation with only the later half so a new agent can continue there.

To set it up, first copy the script:

cp /path/to/this/repo/scripts/check-context.sh ~/.claude/scripts/check-context.sh
chmod +x ~/.claude/scripts/check-context.sh

Then add the hook to your ~/.claude/settings.json:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/scripts/check-context.sh"
          }
        ]
      }
    ]
  }
}

This requires auto-compact to be disabled (/config > Auto-compact > false), otherwise Claude Code may compact the context before the hook gets a chance to fire. When triggered, the hook blocks Claude from stopping and tells it to run /half-clone. The advantage over auto-compact is that half-clone is deterministic and fast - it keeps your actual messages intact instead of summarizing them.

Recommended permission for clone scripts

Both clone scripts need to read ~/.claude (for conversation files and history). To avoid permission prompts from any project, add this to your global settings (~/.claude/settings.json):

{
  "permissions": {
    "allow": ["Read(~/.claude)"]
  }
}

Tip 24: Use realpath to get absolute paths

When you need to tell Claude Code about files in a different folder, use realpath to get the full absolute path:

realpath some/relative/path

Tip 25: Understanding CLAUDE.md vs Skills vs Slash Commands vs Plugins

These are somewhat similar features and I initially found them pretty confusing. I've been unpacking them and trying my best to wrap my head around them, so I wanted to share what I learned.

CLAUDE.md is the simplest one. It's a bunch of files that get treated as the default prompt, loaded into the beginning of every conversation no matter what. The nice thing about it is the simplicity. You can explain what the project is about in a particular project (./CLAUDE.md) or globally (~/.claude/CLAUDE.md).

Skills are like better-structured CLAUDE.md files. They can be invoked by Claude automatically when relevant, or manually by the user with a slash (e.g., /my-skill). For example, you could have a skill that opens a Google Translate link with proper formatting when you ask how to pronounce a word in a certain language. If those instructions are in a skill, they only load when needed. If they were in CLAUDE.md, they'd already be there taking up space. So skills are more token-efficient in theory.

Slash Commands are similar to skills in that they're ways of packaging instructions separately. They can be invoked manually by the user, or by Claude itself. If you need something more precise, to invoke at the right time at your own pace, slash commands are the tool to use.

Skills and slash commands are pretty similar in the way they function. The difference is the intention of the design - skills are primarily designed for Claude to use, and slash commands are primarily designed for the user to use. However, they have ended up merging them, as I had suggested this change.

Plugins are a way to package skills, slash commands, agents, hooks, and MCP servers together. But a plugin doesn't have to use all of them. Anthropic's official frontend-design plugin is essentially just a skill and nothing else. It could be distributed as a standalone skill, but the plugin format makes it easier to install.

For example, I built a plugin called dx that bundles slash commands and a skill from this repo together. You can see how it works in the Install the dx plugin section.

Tip 26: Interactive PR reviews

Claude Code is great for PR reviews. The procedure is pretty simple: you ask it to retrieve PR information using the gh command, and then you can go through the review however you want.

You can do a general review, or go file by file, step by step. You control the pace. You control how much detail you want to look into and the level of complexity you want to work at. Maybe you just want to understand the general structure, or maybe you want to have it run tests too.

The key difference is that Claude Code acts as an interactive PR reviewer, not just a one-shot machine. Some AI tools are good at one-shot reviews (including the latest GPT models), but with Claude Code you can have a conversation.

Tip 27: Claude Code as a research tool

Claude Code is amazing for any sort of research. It's essentially a Google replacement or deep research replacement, but more advanced in a few different ways. Whether you're researching why certain GitHub Actions failed (which I've been doing a lot recently), doing sentiment or market analysis on Reddit, exploring your codebase, or exploring public information to find something - it's able to do that.

The key is giving it the right pieces of information and instructions about how to access those pieces of information. It might be gh terminal command access, or the container approach (Tip 21), or Reddit through Gemini CLI (Tip 11), or private information through an MCP like Slack MCP, or the Cmd+A / Ctrl+A method (Tip 10) - whatever it is. Additionally, if Claude Code has trouble loading certain URLs, you can try using Playwright MCP or Claude's native browser integration (see Tip 9). For scientific research, I created a paper-search plugin for searching academic papers.

In fact, I was even able to save $10,000 by using Claude Code for research.

Tip 28: Mastering different ways of verifying its output

One way to verify its output if it's code is to have it write tests and make sure the tests look good in general. That's one way, but you can of course check the code it generates as it goes, just on the Claude Code UI. Another thing is you can use a visual Git client like GitHub Desktop for example. I personally use it. It's not a perfect product, but it's good enough for checking changes quickly. And having it generate a PR as I probably mentioned earlier in this post is a great way as well. Have it create a draft PR, check the content before turning it into a real PR.

Another one is letting it check itself, its own work. If it gives you some sort of output, let's say from some research, you can say "are you sure about this? Can you double check?" One of my favorite prompts is to say "double check everything, every single claim in what you produced and at the end make a table of what you were able to verify" - and that seems to work really well.

Tip 29: Claude Code as a DevOps engineer

I wanted to specifically create a separate tip for this because it's been really amazing for me. Whenever there are GitHub Actions CI failures, I just give it to Claude Code and say "dig into this issue, try to find the root cause." Sometimes it gives you surface level answers, but if you just keep asking - was it caused by a particular commit, a particular PR, or is it a flaky issue? - it really helps you dig into these nasty issues that are hard to dig into by hand. You would need to wade through a bunch of logs and that would be super painful to do manually, but Claude Code is able to handle a lot of that.

I've packaged this workflow as a /gha slash command - just run /gha <url> with any GitHub Actions URL and it will automatically investigate the failure, check for flakiness, identify breaking commits, and suggest fixes. You can find it in the skills folder, or install it via the dx plugin.

Once you identify what the particular problem was, you can just create a draft PR and go through some of the tips I mentioned earlier - check the output, make sure it looks good, let it verify its own outputs, and then turn it into a real PR to actually fix the issue. It's been working really well for me personally.

Tip 30: Keep CLAUDE.md simple and review it periodically

It's important to keep CLAUDE.md simple and as concise as possible. You can just start with no CLAUDE.md at all. And if you find that you keep telling Claude Code the same thing over and over again, then you can just add it to CLAUDE.md. I know there is an option to do that through the # symbol, but I prefer to just ask Claude Code to either add it to the project level CLAUDE.md or the global CLAUDE.md and it'll know what to edit exactly.

It's also important to periodically review your CLAUDE.md files because they can get outdated over time. Instructions that made sense some time ago might no longer be relevant, or you might have new patterns that should be documented. I created a skill for this called review-claudemd that analyzes your recent conversations and suggests improvements for your CLAUDE.md files.

Tip 31: Claude Code as the universal interface

I used to think with Claude Code, CLI is like the new IDE, and it's still true in a way. I think it's a great first place to open your project whenever you want to make quick edits and stuff like that. But depending on the severity of your project, you want to be more careful about the outputs than just staying at the vibe coding level.

But what's also true, the more general case of that, is that Claude Code is really the universal interface to your computer, the digital world, any sort of digital problem that you have. You can let it figure it out in many cases. For example, if you need to do a quick edit of your video, you can just ask it to do that - it'll probably figure out how to do that through ffmpeg or something similar. If you want to transcribe a bunch of audio files or video files that you have locally, you can just ask it to do that - it might suggest to use Whisper through Python. If you want to analyze some data that you have in a CSV file, it might suggest to use Python or JavaScript to visualize that. And of course with internet access - Reddit, GitHub, MCPs - the possibilities are endless.

It's also great for any operations you want to perform on your local computer. For example, if you're running out of storage, you can just ask it to give you some advice on how to clean that up. It'll look through your local folders and files, try to find what's taking up a lot of space, and then give you advice on how to clean them up - maybe delete particularly large files. In my case, I had some Final Cut Pro files that were really large that I should have cleaned up. Claude Code told me about it. Maybe it'll tell you to clean up unused Docker images and containers using docker system prune. Or maybe it'll tell you to clean up some cache that you never realized was still there. No matter what you want to do on your computer, Claude Code is the first place I go to now.

I think it's kind of interesting because the computer started with a text interface. And we're, in a way, coming back to this text interface that you can spin up three or four tabs at a time, as I mentioned earlier. To me, that's really exciting. It feels like you have a second brain, in a way. But because of the way it's structured, because it's just a terminal tab, you can open up a third brain, a fourth brain, a fifth brain, a sixth brain. And as the models become more powerful, the proportion of the thinking that you can delegate to these things - not the important things, but things that you don't want to do or that you find boring or too tedious - you can just let them take care of it. As I mentioned, a good example of that is looking into GitHub Actions. Who wants to do that? But it turns out these agents are really good at those boring tasks.

Tip 32: It's all about choosing the right level of abstraction

As I mentioned earlier, sometimes it's okay to stay at the vibe coding level. You don't necessarily have to worry about every single line of code if you're working on one-time projects or non-critical parts of the codebase. But other times, you want to dig in a little deeper - look at the file structure and functions, individual lines of code, even checking dependencies.

The key is that it's not binary. Some people say vibe coding is bad because you don't know what you're doing, but sometimes it's totally fine. But other times, it is helpful to dig deeper, use your software engineering skills, understand code at a granular level, or copy and paste parts of the codebase or specific error logs to ask Claude Code specific questions about them.

It's sort of like you're exploring a giant iceberg. If you want to stay at the vibe coding level, you can just fly over the top and check it from far away. Then you can go a little bit closer. You can go into diving mode. You can go deeper and deeper, with Claude Code as your guide.

Tip 33: Audit your approved commands

I recently saw this post where someone's Claude Code ran rm -rf tests/ patches/ plan/ ~/ and wiped their home directory. It's easy to dismiss as a vibe coder mistake, but this kind of mistake could happen to anyone. So it's important to audit your approved commands from time to time. To make it easier, I built cc-safe - a CLI that scans your .claude/settings.json files for risky approved commands.

It detects patterns like:

sudo, rm -rf, Bash, chmod 777, curl | sh
git reset --hard, npm publish, docker run --privileged
And more - it's container-aware so docker exec commands are skipped

It recursively scans all subdirectories, so you can point it at your projects folder to check everything at once. You can run it manually or ask Claude Code to run it for you:

npm install -g cc-safe
cc-safe ~/projects

Or just run it directly with npx:

npx cc-safe .

GitHub: cc-safe

Tip 34: Write lots of tests (and use TDD)

As you write more code with Claude Code, it becomes easier to make mistakes. PR reviews and visual Git clients help catch issues (as I mentioned earlier), but writing tests is crucial as your codebase grows larger.

You can have Claude Code write tests for its own code. Some people say AI can't test its own work, but it turns out it can - similar to how the human brain works. When you write tests, you're thinking about the same problem in a different way. The same applies to AI.

I've found that TDD (Test-Driven Development) works really well with Claude Code:

Write tests first
Make sure they fail
Commit the tests
Write the code to make them pass

This is actually how I built cc-safe. By writing failing tests first and committing them before implementation, you create a clear contract for what the code should do. Claude Code then has a concrete target to hit, and you can verify the implementation is correct by running the tests.

If you want to be extra sure, review the tests yourself to make sure they don't do anything stupid like just returning true.

Tip 35: Be braver in the unknown; iterative problem solving

Since I started using Claude Code more intensely, I've noticed that I became more and more brave in the unknown.

For example, when I started working at Daft, I noticed a problem with our frontend code. I'm not an expert in React, but I decided to dig into it anyway. I just started asking questions about the codebase and about the problem. Eventually I was able to solve it because I knew how to iteratively solve problems with Claude Code.

A similar thing happened recently. I was building a guide for users of Daft and ran into some very specific issues: cloudpickle not working with Google Colab with Pydantic, and a separate issue with Python and a bit of Rust where things weren't printing correctly in JupyterLab even though they worked fine in the terminal. I had never worked with Rust before.

I could have just created an issue and let other engineers handle it. But I thought, let me dig into the codebase. Claude Code came up with an initial solution, but it wasn't that good. So I slowed down. A colleague suggested we just disable that part, but I didn't want any regression. Can we find a better solution?

What followed was a collaborative and iterative process. Claude Code suggested potential root causes and solutions. I experimented with those. Some turned out to be dead ends, so we went in a different direction. Throughout this, I controlled my pace. Sometimes I went faster, like when letting it explore different solution spaces or parts of the codebase. Sometimes I went slower, asking "what does this line mean exactly?" Controlling the level of abstraction, controlling the speed.

Eventually I found a pretty elegant solution. The lesson: even in the world of the unknown, you can do a lot more with Claude Code than you might think.

Tip 36: Running bash commands and subagents in the background

When you have a long-running bash command in Claude Code, you can press Ctrl+B to move it to run in the background. Claude Code knows how to manage background processes - it can check on them later using the BashOutput tool.

This is useful when you realize a command is taking longer than expected and you want Claude to do something else in the meantime. You can then either have it use the exponential backoff method I mentioned in Tip 17 to check on progress, or just let it work on something else entirely while the process runs.

Claude Code also has the ability to run subagents in the background. If you need to do long-running research or have an agent check on something periodically, you don't have to keep it running in the foreground. Just ask Claude Code to run an agent or task in the background, and it'll handle it while you continue with other work.

Using subagents strategically

Beyond just running things in the background, subagents are useful when you have a large task to break down. For example, if you have a huge codebase that you need to analyze, you can have subagents analyze it in different ways or look at different parts of the codebase in parallel. Just ask Claude to spawn multiple subagents to handle different pieces.

You can customize subagents by just asking:

How many - ask Claude to spawn the number you want
Background vs foreground - ask to run them in the background, or press Ctrl+B
Which model - ask for Opus, Sonnet, or Haiku depending on the complexity of each task (subagents default to Sonnet)

Tip 37: The era of personalized software is here

We're entering an era of personalized, custom software. Since AI came out - ChatGPT in general, but especially Claude Code - I've noticed that I'm able to create a lot more software, sometimes just for myself, sometimes for small projects.

As I mentioned earlier in this document, I've created a custom transcription tool that I use every day to talk to Claude Code. I've created ways to customize Claude Code itself. I've also done a bunch of data visualization and data analysis tasks using Python much faster than I could otherwise.

Here's another example: korotovsky/slack-mcp-server, a popular Slack MCP with almost 1,000 stars, is designed to run as a Docker container. I had trouble using it smoothly inside my own Docker container (Docker-in-Docker complications). Instead of fighting with that setup, I just asked Claude Code to write a CLI using Slack's Node SDK directly. It worked really well.

This is an exciting time. Whatever you want to get done, you can ask Claude Code to do it. If it's small enough, you can build it in an hour or two. I even created a slide deck template - a single HTML file with CSS and JavaScript that lets you embed an interactive, persistent terminal process inside.

Tip 38: Navigating and editing your input box

Claude Code's input box is designed to emulate common terminal/readline shortcuts, which makes it feel natural if you're used to working in the terminal. Here are some useful ones:

Navigation:

Ctrl+A - Jump to the beginning of the line
Ctrl+E - Jump to the end of the line
Option+Left/Right (Mac) or Alt+Left/Right - Jump backward/forward by word

Editing:

Ctrl+W - Delete the previous word
Ctrl+U - Delete from cursor to beginning of line
Ctrl+K - Delete from cursor to end of line
Ctrl+C / Ctrl+L - Clear the current input
Ctrl+G - Open your prompt in an external editor (useful for pasting long text, since pasting directly into the terminal can be slow)

If you're familiar with bash, zsh, or other shells, you'll feel right at home.

For Ctrl+G, the editor is determined by your EDITOR environment variable. You can set it in your shell config (~/.zshrc or ~/.bashrc):

export EDITOR=vim      # or nano, code, nvim, etc.

Or in ~/.claude/settings.json (requires restart):

{
  "env": {
    "EDITOR": "vim"
  }
}

Entering newlines (multi-line input):

The quickest method works everywhere without any setup: type \ followed by Enter to create a newline. For keyboard shortcuts, run /terminal-setup in Claude Code. On Mac Terminal.app, I use Option+Enter.

Pasting images:

Ctrl+V (Mac/Linux) or Alt+V (Windows) - Paste an image from your clipboard

Note: On Mac, it's Ctrl+V, not Cmd+V.

Tip 39: Spend some time planning, but also prototype quickly

You want to spend enough time planning so that Claude Code knows what to build and how to build it. This means making high-level decisions early: what technology to use, how the project should be structured, where each functionality should live, which files things should go in. It's important to make good decisions as early as you can.

Sometimes prototyping helps with that. Just by making a simple prototype quickly, you might be able to say "okay, this technology works for this particular purpose" or "this other technology works better."

For example, I was recently experimenting with creating a diff viewer. I first tried a simple bash prototype with tmux and lazygit, then tried making my own git viewer with Ink and Node. I had a lot of trouble with different things and ended up not publishing any of these results. But what I got reminded of through this project is the importance of planning and prototyping. I found that just by planning a little bit better at the beginning before you let it write code, you're able to guide it better. You still need to guide it throughout the process of coding, but letting it plan a little first is really helpful.

You can use plan mode for this by pressing Shift+Tab to switch to it. Or you can just ask Claude Code to make a plan before writing any code.

Tip 40: Simplify overcomplicated code

I've found that Claude Code sometimes overcomplicates things and writes too much code. It makes changes you didn't ask for. It just seems to have a bias for writing more code. The code might work correctly if you've followed the other tips in this guide, but it's going to be hard to maintain and hard to check. It can be kind of a nightmare if you don't review it enough.

So sometimes you want to check the code and ask it to simplify things. You could fix things yourself, but you could also just ask it to simplify. You can ask questions like "why did you make this particular change?" or "why did you add this line?"

Some people say if you write code only through AI, you'll never understand it. But that's only true if you don't ask enough questions. If you make sure you understand every single thing, you can actually understand code faster than otherwise because you can ask AI about it. Especially when you're working on a large project.

Note that this applies to prose as well. Claude Code often tries to summarize previous paragraphs in the last paragraph, or previous sentences in the last sentence. It can get pretty repetitive. Sometimes it's helpful, but most of the time you'll need to ask it to remove or simplify it.

Tip 41: Automation of automation

At the end of the day, it's all about automation of automation. What I mean by that is I've found it's the best way to not just become more productive, but also make the process more fun. At least to me, this whole process of automation of automation is really fun.

I personally started with ChatGPT and wanted to automate the process of copy-pasting and running commands that ChatGPT gave me in the terminal. I automated that whole process by building a ChatGPT plugin called Kaguya. I've consistently worked towards more and more automation since then.

Nowadays, luckily, we don't even have to build a tool like that because tools like Claude Code exist and they work really well. And as I've used it more and more, I found myself thinking, well, what if I could automate the process of typing? So I used Claude Code itself to build my voice transcription app, as I mentioned earlier.

Then I started to think, I find myself repeating myself sometimes. So I would put those things in CLAUDE.md. Then I would think, okay, sometimes I go through running the same command over and over again. How can I automate that? Maybe I can ask Claude Code to do it. Or maybe I can put them in skills. Or maybe I can even have it create a script so I don't have to repeat the same process over and over again.

I think ultimately that's where we're heading. Whenever you find yourself repeating the same task or the same command over and over again, a couple of times is okay, but if you repeat it over and over again, then think about a way to automate that whole process.

Tip 42: Share your knowledge and contribute where you can

This tip is a bit different from the others. I found that by learning as much as you can, you're able to share your knowledge with people around you. Maybe through posts like these, maybe even books, courses, videos. I also recently had an internal session for my colleagues at Daft. It's been very rewarding.

And whenever I share tips, I often get information back. For example, when I shared my trick for shortening the system prompt and tool descriptions (Tip 15), some people told me about the --system-prompt flag that you can use as an alternative. Another time, I shared about the difference between slash commands and skills (Tip 25), and I learned new things from comments on that Reddit post.

So sharing your knowledge isn't just about establishing your brand or solidifying your learning. It's also about learning new things through that process. It's not always a one-way street.

When it comes to contributing, I've been sending issues to the Claude Code repo. I thought, okay, if they listen, cool. If they don't, that's totally fine. I didn't have any expectations. But in version 2.0.67, I noticed they took multiple suggestions from reports I made:

Fixed scroll position resetting after deleting a permission rule in /permissions
Added search functionality to /permissions command

It's kind of amazing how fast the team can react to feature requests and bug reports. But it makes sense because they're using Claude Code to build Claude Code itself.

Tip 43: Keep learning!

There are several effective ways to keep learning about Claude Code:

Ask Claude Code itself - If you have a question about Claude Code, just ask it. Claude Code has a specialized subagent for answering questions about its own features, slash commands, settings, hooks, MCP servers, and more.

Check the release notes - Type /release-notes to see what's new in your current version. This is the best way to learn about the latest features.

Learn from the community - The r/ClaudeAI subreddit is a great place to learn from other users and see what workflows people are using.

Follow Ado for tips - Ado (@adocomplete) is a DevRel at Anthropic who posted daily Claude Code tips throughout December 2025 in his "Advent of Claude" series. While this particular series has already ended, he continues to share useful tips on X.

Tip 44: Install the dx plugin

This repo is also a Claude Code plugin called dx (developer experience). It bundles several tools from the tips above into a single install:

Skill	Description
`/dx:gha <url>`	Analyze GitHub Actions failures (Tip 29)
`/dx:handoff`	Create handoff documents for context continuity (Tip 8)
`/dx:clone`	Clone conversations to branch off (Tip 23)
`/dx:half-clone`	Half-clone to reduce context (Tip 23)
`/dx:reddit-fetch`	Fetch Reddit content via Gemini CLI (Tip 11)
`/dx:review-claudemd`	Review conversations to improve CLAUDE.md files (Tip 30)

Install with two commands:

claude plugin marketplace add ykdojo/claude-code-tips
claude plugin install dx@ykdojo

After installing, the commands are available as /dx:clone, /dx:half-clone, /dx:handoff, and /dx:gha. The reddit-fetch skill is invoked automatically when you ask about Reddit URLs. The review-claudemd skill analyzes your recent conversations and suggests improvements for your CLAUDE.md files. For the clone commands, see the recommended permission.

Recommended companion: Playwright MCP for browser automation - add with claude mcp add -s user playwright npx @playwright/mcp@latest

Tip 45: Quick setup script

If you want to set up multiple recommendations from this repo at once, there's a setup script that handles many of them:

bash <(curl -s https://raw.githubusercontent.com/ykdojo/claude-code-tips/main/scripts/setup.sh)

The script shows you everything it will configure and lets you skip any items:

INSTALLS:
  1. DX plugin - slash commands (/dx:gha, /dx:clone, /dx:handoff) and skills (reddit-fetch)
  2. cc-safe - scans your settings for risky approved commands like 'rm -rf' or 'sudo'

SETTINGS (~/.claude/settings.json):
  3. Status line - shows model, git branch, uncommitted files, token usage at bottom of screen
  4. Disable auto-updates - prevents Claude Code from auto-updating (useful for system prompt patches)
  5. Lazy-load MCP tools - only loads MCP tool definitions when needed, saves context
  6. Read(~/.claude) permission - allows clone/half-clone commands to read conversation history
  7. Read(//tmp/**) permission - allows reading temporary files without prompts
  8. Disable attribution - removes Co-Authored-By from commits and attribution from PRs

SHELL CONFIG (~/.zshrc or ~/.bashrc):
  9. Aliases: c=claude, ch=claude --chrome, cs=claude --dangerously-skip-permissions
 10. Fork shortcut: --fs expands to --fork-session (e.g., claude -c --fs)

Skip any? [e.g., 1 4 7 or Enter for all]:

📺 Related talk: Claude Code Masterclass - lessons and project examples from 31 months of agentic coding

📝 Story: How I got a full-time job with Claude Code

📰 Newsletter: Agentic Coding with Discipline and Skill - bring the practice of agentic coding to the next level

Balackburn/Apollo

Altstore source and website for Apollo for Reddit (with ImprovedCustomApi)

Apollo for Reddit with ImprovedCustomAPI

This AltStore source provides pre-built releases of Apollo App (Christian Selig) injected with ImprovedCustomApi (JeffreyCA).

It uses version 1.15.11 of the app and the latest release of the tweak.

Before raising any issues, please check the ImprovedCustomApi repo first - as this source only integrates it.

Available Sources

Version	Best For	Features
Standard	Most users	Apollo injected with ImprovedCustomApi
No Extensions	Free Apple Developer accounts	Apollo injected with ImprovedCustomApi and removed extensions - Uses fewer App IDs (1 vs 7)
GLASS	iOS 26+ users	Apollo injected with ImprovedCustomApi and Liquid Glass UI Patch (iOS 26+)
No Extensions + LIQUID GLASS	iOS 26 + Free accounts	Combines both options

Standard Source

No Extensions Source (Avoid AppID Limit)

GLASS Source (iOS 26+)

No Extensions + GLASS Source (Avoid AppID Limit - iOS 26+)

Website

This project is not affiliated with Apollo or Christian Selig.

phuc-nt/my-translator

Real-time speech translation — macOS & Windows, free TTS, no server, your API keys only

My Translator is a real-time speech translation desktop app built with Tauri. It captures audio directly from your system or microphone, transcribes it, and displays translations in a minimal overlay — with no intermediary server involved.

📖 Installation guides: macOS (EN) · macOS (VI) · Windows (EN) · Windows (VI)

How It Works

System Audio / Mic → 16kHz PCM → Soniox API (STT + Translation) → Overlay UI
                                                                    ↓ (optional)
                                                            TTS (Edge/Google/ElevenLabs) → 🔊

Feature	Detail
Latency	~2–3s
Languages	70+ (source) → any target, one-way & two-way
Cost	~$0.12/hr (Soniox API)
TTS	3 providers (Edge free, Google, ElevenLabs)
Platform	macOS (ARM + Intel) · Windows
Signed	✅ macOS signed & notarized
Auto-Update	✅ Built-in, check & install from Settings

Features

📖 Dual Panel View

Two display modes:

Single (default) — Translation text only, clean and focused
Dual — Source | Translation side-by-side, each panel scrolls independently

Toggle with the panel button (bottom-right on hover).

🔄 Smart Scroll

Auto-scroll only when you're at the bottom. Scroll up to read old content without being yanked back down.

🔤 Quick Font Size

A- / A+ floating controls (bottom-right on hover). Font size adjustable up to 140px — great for presentations.

🔄 Two-Way Translation

Translate conversations between two languages simultaneously — ideal for bilingual meetings.

One-way: Source language → Target language (e.g., Japanese → Vietnamese)
Two-way: Language A ↔ Language B (e.g., Vietnamese ↔ Japanese) — the app detects who is speaking and translates to the other language automatically

Setup for video calls (Zoom, Google Meet, MS Teams):

Audio Source: Both (System + Mic)
Translation Type: Two-way
Set Language A and Language B

Note: TTS narration is automatically disabled in two-way mode to prevent audio feedback loops (TTS output → mic recapture → re-translation).

🎙️ TTS Narration

Read translations aloud in one-way mode — 3 providers:

	Edge TTS ⭐	Google Chirp 3 HD	ElevenLabs
Cost	Free	Free 1M chars/mo	~$5/mo+
Quality	★★★★☆ Neural	★★★★★ Near-human	★★★★★ Premium
Vietnamese	✅ 2 voices	✅ 6 voices	✅ Yes
Setup	None	Google Cloud API key	API key
Speed control	✅	✅ 0.5x–2.0x	❌

TTS is OFF by default — toggle with the TTS button or ⌘ T.

📖 TTS guide: English · Tiếng Việt

📖 Custom Translation Terms

Define how domain-specific words should be translated:

Original sin = Tội nguyên tổ
Christ = Kitô
Pneumonia = Viêm phổi

Add terms in Settings → Translation → Translation terms. Great for religious, medical, or technical content.

🖥️ Local Mode (Apple Silicon only)

Experimental offline mode using MLX + Whisper + Gemma — runs 100% on-device. JA/EN/ZH/KO → VI/EN.

Privacy

Your audio never touches our servers — because there are none.

App connects directly to APIs you configure — no relay, no middleman
You own your API keys — stored locally, never transmitted elsewhere
No account, no telemetry, no analytics — zero tracking
Transcripts saved as .md files locally, per session

Tech Stack

Tauri 2 — Rust backend + WebView frontend
ScreenCaptureKit — macOS system audio
WASAPI — Windows system audio
cpal — Cross-platform microphone
Soniox — Real-time STT + translation
Edge TTS — Free neural TTS (default)
Google Cloud TTS — Chirp 3 HD (near-human quality)
ElevenLabs — Premium TTS

Build from Source

git clone https://github.com/phuc-nt/my-translator.git
cd my-translator
npm install
npm run tauri build

Requires: Rust (stable), Node.js 18+, macOS 13+ or Windows 10+.

Star History

License

MIT

adobe/skills

Adobe Skills for Agents

Adobe Skills for AI Coding Agents

Repository of Adobe skills for AI coding agents.

Installation

Claude Code Plugins

/plugin marketplace add adobe/skills
/plugin install aem-design@adobe-skills
/plugin install aem-edge-delivery-services@adobe-skills
/plugin install aem-project-management@adobe-skills
/plugin install app-builder@adobe-skills
/plugin install aem-cloud-service@adobe-skills
/plugin install aem-6-5-lts@adobe-skills

Vercel Skills (npx skills)

npx skills add adobe/skills --all

upskill (GitHub CLI Extension)

gh extension install ai-ecoverse/gh-upskill
gh upskill adobe/skills --all

Available Skills

For Business

Adobe Experience Manager

Designing with aem-design

Design-phase skills that run before implementation. Produces static HTML and JSON artifacts under aem-design/ — EDS-independent; no dev server or AEM instance required.

Skill	Description
`aem-design`	Navigator — assesses `aem-design/` state and recommends the next design stage
`brand`	Extracts a brand profile (`brand-profile.json`) and visual brand board from a URL, PDF, or conversation
`briefings`	Captures page intent, audience, key messages, CTAs, and (optionally) final copy under `aem-design/briefings/`
`wireframes`	Produces grey structural wireframes from briefings (section order, hierarchy, spatial relationships) — optional stage
`prototype`	Produces branded, high-fidelity static HTML prototypes that iterate in the browser until approved

Developing with Edge Delivery Services

Skill	Description
`create-site`	Start a brand-new site from scratch: GitHub repo from boilerplate, aem-code-sync, initial DA content (nav, footer, homepage), and live URL handoff
`content-driven-development`	Orchestrates the CDD workflow for all code changes
`analyze-and-plan`	Analyze requirements and define acceptance criteria
`building-blocks`	Implement blocks and core functionality
`testing-blocks`	Browser testing and validation
`content-modeling`	Design author-friendly content models
`code-review`	Self-review and PR review

Discovering Blocks

Skill	Description
`block-inventory`	Survey available blocks in project and Block Collection
`block-collection-and-party`	Search reference implementations
`docs-search`	Search aem.live documentation
`find-test-content`	Find existing content for testing

Migrating Content

Skill	Description
`page-import`	Import webpages (orchestrator)
`scrape-webpage`	Scrape and analyze webpage content
`identify-page-structure`	Analyze page sections
`page-decomposition`	Analyze content sequences
`authoring-analysis`	Determine authoring approach
`generate-import-html`	Generate structured HTML
`preview-import`	Preview imported content

Managing Projects

Handover documentation and PDF guides generation for AEM Edge Delivery Services projects. Available via the aem-project-management plugin.

Skill	Description
`handover`	Orchestrates project documentation generation
`authoring`	Generate comprehensive authoring guide for content authors
`development`	Generate technical documentation for developers
`admin`	Generate admin guide for site administrators
`whitepaper`	Create professional PDF whitepapers from Markdown
`auth`	Authenticate with AEM Config Service API

AEM as a Cloud Service — Create Component

The create-component skill creates complete AEM components following Adobe best practices for AEM Cloud Service and AEM 6.5. It covers:

Component definition, dialog XML, and HTL template
Sling Model and optional child item model (multifield)
Unit tests for models and servlets
Clientlibs (component and dialog)
Optional Sling Servlet for dynamic content

See plugins/aem/cloud-service/skills/create-component/ for the skill and its reference files.

AEM as a Cloud Service — Ensure AGENTS.md (bootstrap)

The ensure-agents-md skill is a bootstrap skill that runs first, before any other work. When a customer opens their AEM Cloud Service project and asks the agent anything, this skill checks whether AGENTS.md exists at the repo root. If missing, it:

Reads root pom.xml to resolve the project name and discover actual modules
Detects add-ons (CIF, Forms, SPA type, precompiled scripts)
Generates a tailored AGENTS.md with only the modules that exist, correct frontend variant, conditional Dispatcher MCP section, and the right resource links
Creates CLAUDE.md (@AGENTS.md) so Claude-based tools also discover the guidance

If AGENTS.md already exists it is never overwritten.

See plugins/aem/cloud-service/skills/ensure-agents-md/ for the skill, template, and module catalog.

AEM Workflow

Workflow skills cover the full AEM Granite Workflow Engine lifecycle — from designing and implementing workflows to production debugging and incident triaging. Like Dispatcher, they are split by runtime flavor:

plugins/aem/cloud-service/skills/aem-workflow — Cloud Service variant (no JMX, Cloud Manager logs, pipeline deploy)
plugins/aem/6.5-lts/skills/aem-workflow — 6.5 LTS / AMS variant (JMX, Felix Console, direct log access)

Each flavor contains the same specialist sub-skills:

Sub-Skill	Purpose
`workflow-model-design`	Design workflow models, step types, OR/AND splits, variables
`workflow-development`	Implement WorkflowProcess steps, ParticipantStepChooser, OSGi services
`workflow-triggering`	Start workflows from UI, code, HTTP API, or Manage Publication
`workflow-launchers`	Configure automatic workflow launchers on JCR events
`workflow-debugging`	Debug stuck, failed, or stale workflows in production
`workflow-triaging`	Classify incidents, determine log patterns, Splunk queries
`workflow-orchestrator`	Full lifecycle orchestration across all sub-skills

AEM Dispatcher

Dispatcher skills are split by runtime flavor to avoid mode auto-detection and keep installation explicit. Install only one dispatcher flavor in a workspace (cloud-service or 6.5-lts).

Current dispatcher flavors:

plugins/aem/cloud-service/skills/dispatcher
plugins/aem/6.5-lts/skills/dispatcher

Each flavor contains parallel capability groups (workflow orchestration, config authoring, technical advisory, incident response, performance tuning, and security hardening). Shared advisory logic is centralized under each flavor's dispatcher/shared/references/ to reduce duplication and drift.

AEM Replication

Replication skills for AEM 6.5 LTS cover the full content distribution lifecycle from agent configuration to troubleshooting.

Location: plugins/aem/6.5-lts/skills/aem-replication

The aem-replication skill contains four specialist sub-skills:

Sub-Skill	Purpose
`configure-replication-agent`	Configure replication agents for publishing, dispatcher flush, and reverse replication
`replicate-content`	Activate and deactivate content using UI, workflows, and package manager
`replication-api`	Use the Replication API programmatically in custom code with complete Java examples
`troubleshoot-replication`	Diagnose and fix blocked queues, connectivity failures, and distribution problems

Key features:

All skills based on official AEM 6.5 LTS documentation
Complete coverage of public Replication API (Replicator, ReplicationOptions, AgentManager, ReplicationQueue, etc.)
49 Java code examples for OSGi services, servlets, and workflow steps
12+ troubleshooting scenarios with step-by-step resolution
3,575 lines of comprehensive documentation

AEM as a Cloud Service — Rapid Development Environment (RDE) (beta)

The aem-rde skill provides expert assistance for the Adobe I/O CLI plugin @adobe/aio-cli-plugin-aem-rde — used to deploy, inspect, log-tail, snapshot, and troubleshoot AEM Rapid Development Environments via aio aem rde … commands. The skill activates only on explicit RDE references; generic AEMaaCS deployment requests are deferred to Cloud Manager skills.

Skill	Description
`aem-rde` (beta)	Translate goals into the right `aio aem rde` commands (deploy, status, history, logs, inspect, snapshot, setup); diagnose RDE problems; guide setup, experimental feature flags, and CI/build-environment usage

See plugins/aem/cloud-service/skills/aem-rde/ for the skill and its reference files (commands, configuration, deployment types, troubleshooting, workflows).

AEM as a Cloud Service — Best Practices & Migration

Under plugins/aem/cloud-service/skills/, best-practices/ is the general-purpose Cloud Service skill: pattern modules, Java baseline references (SCR→OSGi DS, resolver/logging, and related refs), and day-to-day Cloud Service alignment. Use it without loading migration for greenfield or maintainability work. migration/ (BPA/CAM orchestration) is scoped to legacy AEM → AEM as a Cloud Service (not Edge Delivery or 6.5 LTS); it delegates concrete refactors to best-practices (references/). Installing the AEM as a Cloud Service plugin (aem-cloud-service, or the plugins/aem/cloud-service path with npx skills / gh upskill) includes both; the agent should load the appropriate SKILL.md for the task. Use gh upskill / npx skills with --skill when you need a specific bundled skill (see Installation above).

Key features:

Best practices: one skill for patterns, SCR→OSGi DS, and resolver/logging — applicable to Cloud Service projects generally, not only migration
Migration: orchestration-only; pattern and transformation content lives in best-practices

App Builder

Development, customization, testing, and deployment skills for Adobe App Builder projects.

Skill chaining:

Actions path: appbuilder-project-init → appbuilder-action-scaffolder → appbuilder-testing → appbuilder-cicd-pipeline
UI path: appbuilder-project-init → appbuilder-ui-scaffolder → appbuilder-testing → appbuilder-cicd-pipeline
E2E path: appbuilder-ui-scaffolder or appbuilder-testing → appbuilder-e2e-testing → appbuilder-cicd-pipeline

Skill	Description
`appbuilder-project-init`	Initialize new Adobe App Builder projects and choose the right bootstrap path
`appbuilder-action-scaffolder`	Scaffold, implement, deploy, and debug Adobe Runtime actions
`appbuilder-ui-scaffolder`	Generate React Spectrum UI components for ExC Shell SPAs and AEM UI Extensions
`appbuilder-testing`	Generate and run Jest unit, integration, and contract tests for actions and UI components
`appbuilder-e2e-testing`	Playwright browser E2E tests for ExC Shell SPAs and AEM extensions
`appbuilder-cicd-pipeline`	Set up CI/CD pipelines for GitHub Actions, Azure DevOps, and GitLab CI

Creativity & Design

Skill	Description
`adobe-batch-edit-photos`	Apply consistent, cohesive photo adjustments across a set of images — matched tones, presets, and cinematic looks
`adobe-design-from-template`	Create flyers, posters, social posts, invitations, business cards, and other visuals from Adobe Express templates
`adobe-retouch-portraits`	Bulk walk-away retouching for wedding and event portraits: auto-straighten, auto-tone, and auto-light across a folder
`adobe-edit-quick-cut`	Turn a long video into a punchy sizzle or highlight reel using Adobe Quick Cut
`adobe-resize-photos-and-videos`	Resize images and videos to exact pixel dimensions, aspect ratios, or named sizes (4K, HD, A4)
`adobe-create-social-variations`	Produce platform-ready image and video crops for Instagram, TikTok, LinkedIn, YouTube, and other social platforms

Repository Structure

plugins/
├── aem/
│   ├── edge-delivery-services/
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json
│   │   └── skills/
│   │       ├── content-driven-development/
│   │       ├── building-blocks/
│   │       └── ...
│   ├── project-management/
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json
│   │   ├── fonts/
│   │   ├── hooks/
│   │   │   └── pdf-lifecycle.js
│   │   ├── templates/
│   │   │   └── whitepaper.typ
│   │   └── skills/
│   │       ├── handover/
│   │       ├── authoring/
│   │       ├── development/
│   │       ├── admin/
│   │       ├── whitepaper/
│   │       └── auth/
│   ├── cloud-service/
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json
│   │   └── skills/
│   │       ├── best-practices/
│   │       │   ├── README.md
│   │       │   ├── SKILL.md
│   │       │   └── references/
│   │       ├── migration/
│   │       │   ├── README.md
│   │       │   ├── SKILL.md
│   │       │   ├── references/
│   │       │   └── scripts/
│   │       ├── ensure-agents-md/
│   │       │   ├── SKILL.md
│   │       │   └── references/
│   │       │       ├── AGENTS.md.template
│   │       │       └── module-catalog.md
│   │       ├── create-component/
│   │       │   ├── SKILL.md
│   │       │   ├── assets/
│   │       │   └── references/
│   │       ├── aem-workflow/
│   │       │   ├── SKILL.md
│   │       │   ├── workflow-model-design/
│   │       │   ├── workflow-development/
│   │       │   ├── workflow-triggering/
│   │       │   ├── workflow-launchers/
│   │       │   ├── workflow-debugging/
│   │       │   ├── workflow-triaging/
│   │       │   └── workflow-orchestrator/
│   │       └── dispatcher/
│   │           ├── SKILL.md
│   │           ├── config-authoring/
│   │           ├── technical-advisory/
│   │           ├── incident-response/
│   │           ├── performance-tuning/
│   │           ├── security-hardening/
│   │           └── workflow-orchestrator/
│   └── 6.5-lts/
│       ├── .claude-plugin/
│       │   └── plugin.json
│       └── skills/
│           ├── aem-workflow/
│           │   ├── SKILL.md
│           │   ├── workflow-model-design/
│           │   ├── workflow-development/
│           │   ├── workflow-triggering/
│           │   ├── workflow-launchers/
│           │   ├── workflow-debugging/
│           │   ├── workflow-triaging/
│           │   └── workflow-orchestrator/
│           ├── aem-replication/
│           │   ├── README.md
│           │   ├── SKILL.md
│           │   ├── configure-replication-agent/
│           │   ├── replicate-content/
│           │   ├── replication-api/
│           │   └── troubleshoot-replication/
│           ├── ensure-agents-md/
│           └── dispatcher/
│               ├── SKILL.md
│               ├── config-authoring/
│               ├── technical-advisory/
│               ├── incident-response/
│               ├── performance-tuning/
│               ├── security-hardening/
│               └── workflow-orchestrator/
├── app-builder/
│   ├── .claude-plugin/
│   │   └── plugin.json
│   └── skills/
│       ├── _shared/
│       ├── appbuilder-project-init/
│       ├── appbuilder-action-scaffolder/
│       ├── appbuilder-ui-scaffolder/
│       ├── appbuilder-testing/
│       ├── appbuilder-e2e-testing/
│       └── appbuilder-cicd-pipeline/
└── creative-cloud/
    └── adobe-for-creativity/
        ├── .claude-plugin/
        │   └── plugin.json
        ├── skills/
        │   └── ...
        └── .mcp.json

Contributing

See CONTRIBUTING.md for guidelines on adding or updating skills. Join #agentskills on Adobe Slack for questions and discussion.

Resources

License

Apache 2.0 — see LICENSE for details.

qist/tvbox

OK影视、tvbox配置文件，如果喜欢，请Fork自用。使用前请仔细阅读仓库说明，一旦使用将被视为你已了解。

OK影视、TVBox、猫影视配置文件。所有资源均来自于各路大神无私分享，如有侵权，请联系删除。

tvbox配置：

（1）0707.json OK影视多线配置接口,仅适用于Fengmi影视；

（2）0821.json 大而全的配置，在饭太硬配置的基础上添加了若干优质点播源、直播线路和解析；

（3）0822.json 极简配置，OK大佬的jar，还包括几条路飞、俊于的源。

（4）0825.json 小而精的配置，jar包来源于Panda Groove的go包，其中泥巴、星星等，需要替换成自己的代理url；

（5）0826.json 完全来源于饭太硬的jar包和配置；

（6）0827.json jar包和配置来源于fongmi；

（7）0828.json jar包和配置来源于唐三；

（8）js.json jar包来源于Panda Groove的go包，资源来源于道长drpy(js)仓库添加 YouTube 直播；

（9）XBPQ.json XBPQ源，jar包和配置来源于小米小爆脾气；

（10）XYQ.json XYQ源，jar包和配置来源于香雅情；

（11）cat.json cat源，资源来源于网络各路大佬。/cat/js配合猫影视可直接食用；

（12） jsm.json 来自js.json + 0826.json 合集家庭电视可用删除YouTube 直播，OK影视可用电视建议使用OK影视 https://github.com/FongMi/Release 支持多直播选择。

猫影视使用github 配置

配置教程：https://omii.top/1296.html

注意使用Gitee或Github导入，并设置为私有仓库，CatVodOpen仅支持私有仓库跟dav

V1.1.3版本以上

github://Token@github.com/xxxxx/tvbox/dist/index.js.md5

改动

quickjs改为nodejs，proxy设置修改
在ios上无法使用local，使用db替换local所有方法
nodejs 的优势在于更加灵活

V1.1.2版本以下

github://Token@gitee.com/xxxxx/tvbox/js/open_config.json

APP推荐:

（1）OK影视版本项目地址：https://github.com/FongMi/TV 支持直播多线路、自动换源、直播倍速，手机投屏；

（2）q215613905版本项目地址：https://github.com/q215613905/TVBoxOS 支持直播回放；

（3）takagen99版本项目地址：https://github.com/takagen99/Box 支持直播回放，界面美观；

（4）皮皮虾版本发布频道：https://t.me/pipixiawerun 支持直播回放，支持弹幕；

（5）新版猫影视项目地址：https://github.com/catvod/CatVodOpen 界面简洁，支持多平台。

（6）手机版本项目地址：https://github.com/XiaoRanLiu3119/TVBoxOS-Mobile 竖屏

（7）q215613905 takagen99 编译apk 项目地址：https://github.com/o0HalfLife0o/TVBoxOSC

TVBox各路大佬配置（排名不分先后）：

（1）饭太硬：http://www.饭太硬.top/tv/

（2）okjack：https://jihulab.com/okcaptain/kko/raw/main/ok.txt

（3）王二小放牛娃：http://tvbox.王二小放牛娃.xyz

（4）摸鱼儿：http://我不是.摸鱼儿.top

（5）霜辉月明py：https://raw.githubusercontent.com/lm317379829/PyramidStore/pyramid/py.json

（6）小米小爆脾气：http://xhww.fun/小米/DEMO.json

（7）南风：https://agit.ai/Yoursmile7/TVBox/raw/branch/master/XC.json

（8）神器：https://神器每日推送.tk/pz.json

（9）巧技：http://pandown.pro/tvbox/tvbox.json

（10）Ray：https://100km.top/0

（11）俊于：http://home.jundie.top:81/top98.json

（12）橘子柚：https://raw.githubusercontent.com/hackyjso/box/main/jzy.txt

（13）电视（自用）： https://raw.githubusercontent.com/qist/tvbox/master/jsm.json

（14）github代理地址： https://github.moeyy.xyz https://mirror.ghproxy.com/ https://gh-proxy.com https://ghproxy.net 选择一个速度快使用

（15）还可以使用域名: https://qist.wyfc.qzz.io/jsm.json cloudflare Pages 构建

（16）添加潇洒接口： https://raw.githubusercontent.com/qist/tvbox/master/xiaosa/api.json 或者 https://qist.wyfc.qzz.io/xiaosa/api.json

（17）添加饭太硬接口 https://raw.githubusercontent.com/qist/tvbox/master/fty.json 或者 https://qist.wyfc.qzz.io/fty.json

网盘授权配置：选择《配置 | 中心》进行配置特别警告：据传阿里要求使用者不得使用多线程加速方式使用阿里云盘资源，若并发连接数超过10有可能导致被限制访问或封禁帐号的处理，所以下方线程限制设置超过10所需承担的风险请使用者自行斟酌。

特别警告2：迅雷云盘限制极为严格，不要尝试单token多用户异地使用，或多线程使用，随时可能封号。

可以透过配置中的“网盘及弹幕配置”的视频源来实现快捷方便的获取32位token及opentoken的功能。在“网盘及弹幕配置”中扫过任何一个OpenToken后，会自动激活“转存原画”功能

提示：如果遇到极速GO原画反复快速报错，不一定是被封号，可尝试杀掉播放器重启，或重启整个播放设备解决。

提示2：如果遇到“转存原画”速度被限制在2M左右，那麽请尝试在阿里云盘APP里退出登录，然后重新登录，然后删除播放设备SD卡的TV目

自用仓库，如果喜欢，请Fork自用，谢谢！

尽自己所能更新，不保证配置的有效性和时效性。

Star

facebook/react

The library for web and native user interfaces.

React ·

React is a JavaScript library for building user interfaces.

Declarative: React makes it painless to create interactive UIs. Design simple views for each state in your application, and React will efficiently update and render just the right components when your data changes. Declarative views make your code more predictable, simpler to understand, and easier to debug.
Component-Based: Build encapsulated components that manage their own state, then compose them to make complex UIs. Since component logic is written in JavaScript instead of templates, you can easily pass rich data through your app and keep the state out of the DOM.
Learn Once, Write Anywhere: We don't make assumptions about the rest of your technology stack, so you can develop new features in React without rewriting existing code. React can also render on the server using Node and power mobile apps using React Native.

Learn how to use React in your project.

Installation

React has been designed for gradual adoption from the start, and you can use as little or as much React as you need:

Use Quick Start to get a taste of React.
Add React to an Existing Project to use as little or as much React as you need.
Create a New React App if you're looking for a powerful JavaScript toolchain.

Documentation

You can find the React documentation on the website.

Check out the Getting Started page for a quick overview.

The documentation is divided into several sections:

You can improve it by sending pull requests to this repository.

Examples

We have several examples on the website. Here is the first one to get you started:

import { createRoot } from 'react-dom/client';

function HelloMessage({ name }) {
  return <div>Hello {name}</div>;
}

const root = createRoot(document.getElementById('container'));
root.render(<HelloMessage name="Taylor" />);

This example will render "Hello Taylor" into a container on the page.

You'll notice that we used an HTML-like syntax; we call it JSX. JSX is not required to use React, but it makes code more readable, and writing it feels like writing HTML.

Contributing

The main purpose of this repository is to continue evolving React core, making it faster and easier to use. Development of React happens in the open on GitHub, and we are grateful to the community for contributing bugfixes and improvements. Read below to learn how you can take part in improving React.

Code of Conduct

Facebook has adopted a Code of Conduct that we expect project participants to adhere to. Please read the full text so that you can understand what actions will and will not be tolerated.

Contributing Guide

Read our contributing guide to learn about our development process, how to propose bugfixes and improvements, and how to build and test your changes to React.

Good First Issues

To help you get your feet wet and get you familiar with our contribution process, we have a list of good first issues that contain bugs that have a relatively limited scope. This is a great place to get started.

License

React is MIT licensed.

renatoasse/opensquad

opensquad

Crie squads de agentes de IA que trabalham juntos — direto da sua IDE.

opensquad é um framework de orquestração multi-agente. Descreva o que você precisa em linguagem natural, e o opensquad cria uma equipe de agentes especializados que trabalham juntos automaticamente.

Veja em ação

O que é um Squad?

Um squad é uma equipe de agentes de IA que colaboram em uma tarefa. Cada agente tem um papel específico. Eles executam em pipeline com checkpoints onde o agente pausa e pede sua aprovação antes de continuar. Os checkpoints são instruções no pipeline do agente — o enforcement real de permissões depende da IDE host (ex: Claude Code, Cursor).

Exemplo:

Pesquisador coleta informações e tendências do setor
Estrategista gera ideias e define a abordagem
Redator produz o conteúdo final
Designer cria as imagens para redes sociais
Revisor garante qualidade antes da entrega

Para quem?

Para qualquer pessoa ou equipe que queira automatizar trabalho operacional e repetitivo com agentes de IA.

Criadores de conteúdo — automatize pesquisa, redação e design para redes sociais, blogs e newsletters
Agências e freelancers — crie pipelines reutilizáveis para atender múltiplos clientes
Times de marketing — produza conteúdo consistente com aprovação humana nos checkpoints
Times de RH — automatize triagem de currículos, comunicações internas e onboarding
Times de gestão — gere relatórios, apresentações e dashboards a partir de dados brutos

O que dá pra fazer?

Produção de conteúdo — carrosséis, posts estáticos, artigos de blog, LinkedIn, com publicação automática inclusa
Refatoração de conteúdo — transformar um vídeo em carrossel, artigo, thread ou qualquer outro formato
Criação e edição de vídeos — cortar vídeos longos em reels, montar vídeos do zero
Análise de dados — transformar planilhas em apresentações, sites ou dashboards
Planejamento de campanhas — gerar roteiros, e-mails, mensagens de WhatsApp, cronogramas de lançamento, tudo de uma vez
Roteiros de vídeos longos — VSLs, webinars, aulas
Radar de tendências — monitorar notícias e tendências do nicho e alimentar automaticamente outros squads, como o de produção de conteúdo
Tutoriais e manuais — o agente navega na internet, bate prints e monta um documento completo passo a passo (ideal para manuais de SaaS)
E muito mais — qualquer fluxo de trabalho que envolva pesquisa, criação ou automação

Instalação

Pré-requisito: Node.js 20+

npx opensquad init

Para atualizar uma instalação existente:

npx opensquad update

IDEs Suportadas

IDE	Status
Claude Code	Disponível
Cursor	Disponível
VS Code + Copilot	Disponível
Codex (OpenAI)	Disponível
Open Code	Disponível
Antigravity	Disponível
Gemini CLI	Disponível
Qwen Code	Disponível
Trae	Disponível

Escritório Virtual

O Escritório Virtual é uma interface visual 2D que mostra seus agentes trabalhando em tempo real.

Passo 1 — Gere o dashboard (na sua IDE):

/opensquad dashboard

Passo 2 — Sirva localmente (no terminal):

npx serve squads/<nome-do-squad>/dashboard

Passo 3 — Abra http://localhost:3000 no seu navegador.

Criando seu Squad

Abra o menu:

/opensquad

O Opensquad vai te mostrar todas as opções disponíveis.

Para criar um novo squad, basta selecionar a opção, e o Arquiteto faz algumas perguntas, projeta o squad e configura tudo automaticamente. Você aprova o design antes de qualquer execução.

Executando um Squad

Você pode executar o squad novamente com /opensquad, ou pedindo diretamente:

/opensquad rode o squad <nome-do-squad>

O squad executa automaticamente, pausando nos checkpoints onde o agente pede sua aprovação.

Exemplos

/opensquad
/opensquad crie um Squad que gera carrosséis de Instagram a partir de notícias quentes, cria as imagens e publica automaticamente
/opensquad quero um Squad que produz todos os materiais de lançamento de infoproduto: páginas de vendas, mensagens de WhatsApp, emails e roteiros de CPL
/opensquad crie um Squad que escreve tutoriais completos com prints de tela para treinamento de colaboradores
/opensquad crie um "Squad que pega vídeos do YouTube e gera cortes virais automaticamente"
/opensquad roda o squad carrosseis-instagram

Comandos

Comando	O que faz
`/opensquad`	Abre o menu principal
`/opensquad help`	Mostra todos os comandos
`/opensquad create`	Cria um novo squad
`/opensquad run <nome>`	Executa um squad
`/opensquad list`	Lista seus squads
`/opensquad edit <nome>`	Modifica um squad
`/opensquad skills`	Navega pelas skills instaladas
`/opensquad install <nome>`	Instala uma skill do catálogo
`/opensquad uninstall <nome>`	Remove uma skill instalada

Custo de Tokens

O opensquad é open source e gratuito como software. É possível usá-lo de forma 100% gratuita com stacks como Google Antigravity (free tier com Gemini) ou OpenCode com LLMs locais (Ollama, LM Studio, etc.).

Porém, stacks como Claude Code (Claude Pro/Max) e API da OpenAI consomem tokens pagos:

Cada execução de squad consome tokens — a quantidade depende do número de agentes, da complexidade do pipeline e do modelo escolhido.
Investigações com Sherlock (navegação de perfis) e geração de imagens são operações especialmente intensivas.
O framework carrega prompts de sistema, best practices e instruções de agentes no contexto — o que contribui para o consumo base de cada execução.

Se estiver usando uma stack paga, recomendamos monitorar seu consumo de tokens na sua IDE ou no dashboard do provedor de IA.

Sessões de Navegador e Privacidade

Quando você fornece URLs de referência durante a criação de um squad (ex: "siga o estilo do @fulano"), o opensquad usa um navegador headless (Playwright) para visitar essas páginas e extrair padrões de conteúdo.

Login manual: na primeira vez que uma plataforma exige login, o opensquad pede para você entrar manualmente e pergunta se deseja salvar a sessão para investigações futuras.
Cookies persistentes: se você autorizar, os cookies ficam salvos localmente em _opensquad/_browser_profile/. Esse diretório nunca é commitado no git (.gitignore).
Escopo de acesso: o navegador tem acesso a qualquer URL — não apenas às referências fornecidas. As ações do navegador (navegação, cliques, execução de JavaScript) são controladas pelo agente investigador.
Revogar sessões: delete a pasta _opensquad/_browser_profile/ para remover todos os cookies e dados de sessão salvos. Na próxima investigação, um novo login manual será necessário.

Sobre

O opensquad é um projeto open source criado e mantido por Renato Asse, fundador da Comunidade Sem Codar, uma Escola de IA com mais de 25 mil alunos focada em ensinar pessoas não-técnicas a usar inteligência artificial no trabalho.

O projeto nasceu da necessidade real de automatizar processos de conteúdo e marketing usando agentes de IA — e é disponibilizado gratuitamente para que qualquer pessoa possa usar, estudar e contribuir.

Contribuições da comunidade são bem-vindas. Veja o CONTRIBUTING.md para saber como participar.

Licença

MIT — use como quiser.

opensquad (English)

Create AI squads that work together — right from your IDE.

opensquad is a multi-agent orchestration framework. Describe what you need in plain language, and opensquad creates a team of specialized agents that work together automatically.

See it in action

What is a Squad?

A squad is a team of AI agents that collaborate on a task. Each agent has a specific role. They run in a pipeline with checkpoints where the agent pauses and asks for your approval before continuing. Checkpoints are instructions in the agent pipeline — actual permission enforcement depends on the host IDE (e.g., Claude Code, Cursor).

Example:

Researcher gathers information and industry trends
Strategist generates ideas and defines the approach
Writer produces the final content
Reviewer ensures quality before delivery

Installation

Prerequisite: Node.js 20+

npx opensquad init

Note: Always run your AI IDE from inside the project directory where you ran npx opensquad init. The /opensquad command is only available when the IDE is opened in that folder.

To update an existing installation:

npx opensquad update

Supported IDEs

IDE	Status
Claude Code	Available
Cursor	Available
VS Code + Copilot	Available
Codex (OpenAI)	Available
Open Code	Available
Antigravity	Available
Gemini CLI	Available
Qwen Code	Available
Trae	Available

Virtual Office

The Virtual Office is a 2D visual interface that shows your agents working in real time.

Step 1 — Generate the dashboard (in your IDE):

/opensquad dashboard

Step 2 — Serve it locally (in terminal):

npx serve squads/<squad-name>/dashboard

Step 3 — Open http://localhost:3000 in your browser.

Creating your Squad

Describe what you need:

/opensquad create "A squad that writes LinkedIn posts about AI trends"

The Architect asks a few questions, designs the squad, and sets everything up automatically. You approve the design before any execution begins.

Running a Squad

/opensquad run <squad-name>

The squad runs automatically, pausing at checkpoints where the agent asks for your approval.

Examples

/opensquad create "Squad that generates Instagram carousels from trending news, creates the images, and publishes automatically"
/opensquad create "Squad that produces all infoproduct launch materials: sales pages, WhatsApp messages, emails, and CPL scripts"
/opensquad create "Squad that writes complete tutorials with screenshots for employee training"
/opensquad create "Squad that takes YouTube videos and automatically generates viral clips"

Commands

Command	What it does
`/opensquad`	Open the main menu
`/opensquad help`	Show all commands
`/opensquad create`	Create a new squad
`/opensquad run <name>`	Run a squad
`/opensquad list`	See all your squads
`/opensquad edit <name>`	Modify a squad
`/opensquad skills`	Browse installed skills
`/opensquad install <name>`	Install a skill from catalog
`/opensquad uninstall <name>`	Remove an installed skill

Token Cost

opensquad is open source and free as software. You can use it completely free with stacks like Google Antigravity (free tier with Gemini) or OpenCode with local LLMs (Ollama, LM Studio, etc.).

However, stacks like Claude Code (Claude Pro/Max) and OpenAI API consume paid tokens:

Every squad run consumes tokens — the amount depends on the number of agents, pipeline complexity, and the model chosen.
Sherlock investigations (profile browsing) and image generation are especially token-intensive operations.
The framework loads system prompts, best practices, and agent instructions into context — contributing to the base token consumption of every run.

If using a paid stack, we recommend monitoring your token usage in your IDE or your AI provider's dashboard.

Browser Sessions & Privacy

When you provide reference URLs during squad creation (e.g., "follow the style of @someone"), opensquad uses a headless browser (Playwright) to visit those pages and extract content patterns.

Manual login: the first time a platform requires login, opensquad asks you to log in manually and asks whether you want to save the session for future investigations.
Persistent cookies: if you agree, cookies are saved locally in _opensquad/_browser_profile/. This directory is never committed to git (.gitignore).
Access scope: the browser can access any URL — not just the references you provided. Browser actions (navigation, clicks, JavaScript execution) are controlled by the investigator agent.
Revoking sessions: delete the _opensquad/_browser_profile/ folder to remove all saved cookies and session data. The next investigation will require a fresh manual login.

About

opensquad is an open source project created and maintained by Renato Asse, founder of Comunidade Sem Codar (No-Code Community), an AI School with over 25,000 students focused on teaching non-technical people how to use artificial intelligence at work.

The project was born from the real need to automate content and marketing workflows using AI agents — and is made freely available so anyone can use, study, and contribute.

Community contributions are welcome. See CONTRIBUTING.md to learn how to participate.

License

MIT — use it however you want.

copy/v86

x86 PC emulator and x86-to-wasm JIT, running in the browser

or #v86 on irc.libera.chat

v86 emulates an x86-compatible CPU and hardware. Machine code is translated to WebAssembly modules at runtime in order to achieve decent performance. Here's a list of emulated hardware:

An x86-compatible CPU. The instruction set is around Pentium 4 level, including full SSE3 support. Some features are missing, in particular:
- Task gates, far calls in protected mode
- Some 16 bit protected mode features
- Single stepping (trap flag, debug registers)
- Some exceptions, especially floating point and SSE
- Multicore
- 64-bit extensions
A floating point unit (FPU). Calculations are done using the Berkeley SoftFloat library and therefore should be precise (but slow). Trigonometric and log functions are emulated using 64-bit floats and may be less precise. Not all FPU exceptions are supported.
A floppy disk controller (8272A).
An 8042 Keyboard Controller, PS2. With mouse support.
An 8254 Programmable Interval Timer (PIT).
An 8259 Programmable Interrupt Controller (PIC).
Partial APIC support.
A CMOS Real Time Clock (RTC).
A generic VGA card with SVGA support and Bochs VBE Extensions.
A PCI bus. This one is partly incomplete and not used by every device.
An IDE disk controller.
- A built-in ISO 9660 CD-ROM generator.
An NE2000 (RTL8390) PCI network card.
Various virtio devices: Filesystem, network and balloon.
A SoundBlaster 16 sound card.
A hayes-compatible dial-up Modem.

Demos

9front — Arch Linux — Android-x86 1.6-r2 — Android-x86 4.4-r2 — BasicLinux — Buildroot Linux — Damn Small Linux — ELKS — FreeDOS — FreeBSD — FiwixOS — Haiku — SkiffOS — ReactOS — Windows 2000 — Windows 98 — Windows 95 — Windows 1.01 — MS-DOS 6.22 — OpenBSD — Oberon — KolibriOS — SkiftOS — QNX

Documentation

How it works — Networking — Dial-up modem networking — Alpine Linux guest setup — Arch Linux guest setup — Windows NT guest setup — Windows 9x guest setup — 9p filesystem — Linux rootfs on 9p — Profiling — CPU Idling

Compatibility

Here's an overview of the operating systems supported in v86:

Linux works pretty well. 64-bit kernels are not supported.
- Buildroot can be used to build a minimal image. humphd/browser-vm and darin755/browser-buildroot have some useful scripts for building one.
- SkiffOS (based on Buildroot) can cross-compile a custom image.
- Ubuntu and other Debian derivatives works up to the latest version that supported i386 (16.04 LTS or 18.04 LTS for some variants).
- Alpine Linux works. An image can be built from a Dockerfile, see tools/docker/alpine/.
- Arch Linux 32 works. See archlinux.md for building an image.
ReactOS works.
FreeDOS, Windows 1.01 and MS-DOS run very well.
KolibriOS works.
Haiku works.
Android-x86 has been tested up to 4.4-r2.
Windows 1, 3.x, 95, 98, ME, NT and 2000 work reasonably well.
- In Windows 2000 and higher the PC type has to be changed from ACPI PC to Standard PC
- There are some known boot issues (#250, #433, #507, #555, #620, #645)
- See Windows 9x guest setup
Windows XP, Vista and 8 work under certain conditions (see #86, #208)
- See Windows NT guest setup
Many hobby operating systems work.
9front works.
Plan 9 doesn't work.
QNX works.
OS/2 doesn't work.
FreeBSD works.
OpenBSD works with a specific boot configuration. At the boot> prompt type boot -c, then at the UKC> prompt disable mpbios and exit.
NetBSD works only with a custom kernel, see #350.
SerenityOS works (only 32-bit versions).
SkiftOS works.

You can get some information on the disk images here: https://github.com/copy/images.

How to build, run and embed?

You need:

make
Rust with the wasm32-unknown-unknown target
A version of clang compatible with Rust
java (for Closure Compiler, not necessary when using debug.html)
nodejs (a recent version is required, v16.11.1 is known to be working)
To run tests: nasm, gdb, qemu-system, gcc, libc-i386 and rustfmt

See tools/docker/test-image/Dockerfile for a full setup on Debian or WSL.

Run make to build the debug build (at debug.html).
Run make all to build the optimized build (at index.html).
ROM and disk images are loaded via XHR, so if you want to try out index.html locally, make sure to serve it from a local webserver. You can use make run to serve the files using Python's http module.
If you only want to embed v86 in a webpage you can use libv86.js. For usage, check out the examples. You can download it from the release section.
For bundler-based setups (Vite/React/Next/Webpack), there is also an official npm package: https://www.npmjs.com/package/v86

This package was originally maintained by @giulioz (bundler-optimized fork) and was made "official" for this repo by @basicer with the author's permission. It is published automatically from this repository via GitHub Actions (.github/workflows/ci.yml, Upload release job) on pushes to master and uses npm publish --provenance.

Install: npm install v86

Alternatively, to build using Docker

If you have Docker installed, you can run the whole system inside a container.
See tools/docker/exec to find the Dockerfile required for this.
You can run docker build -f tools/docker/exec/Dockerfile -t v86:alpine-3.19 . from the root directory to generate docker image.
Then you can simply run docker run -it -p 8000:8000 v86:alpine-3.19 to start the server.
Check localhost:8000 for hosted server.

Running via Dev Container

If you are using an IDE that supports Dev Containers, such as GitHub Codespaces, the Visual Studio Code Remote Container extension, or possibly others such as Jetbrains' IntelliJ IDEA, you can setup the development environment in a Dev Container.
Follow the instructions from your development environment to setup the container.
Run the Task "Fetch images" in order to download images for testing.

Testing

The disk images for testing are not included in this repository. You can download them directly from the website using:

curl --compressed --output-dir images/ --remote-name-all https://i.copy.sh/{linux.iso,linux3.iso,linux4.iso,buildroot-bzimage68.bin,TinyCore-11.0.iso,oberon.img,msdos.img,openbsd-floppy.img,kolibri.img,windows101.img,os8.img,freedos722.img,mobius-fd-release5.img,msdos622.img}

Run integration tests: make tests

Run all tests: make jshint rustfmt kvm-unit-test nasmtests nasmtests-force-jit expect-tests jitpagingtests qemutests rust-test tests

See tests/Readme.md for more information.

API examples

Using v86 for your own purposes is as easy as:

var emulator = new V86({
    screen_container: document.getElementById("screen_container"),
    bios: {
        url: "../../bios/seabios.bin",
    },
    vga_bios: {
        url: "../../bios/vgabios.bin",
    },
    cdrom: {
        url: "../../images/linux.iso",
    },
    autostart: true,
});

See v86.d.ts for TypeScript definitions. You can use make doc (TypeDoc) or make denodoc (Deno) to generate HTML documentation in ./docs/api/.

License

v86 is distributed under the terms of the Simplified BSD License, see LICENSE. The following third-party dependencies are included in the repository under their own licenses:

lib/softfloat/softfloat.c
lib/zstd/zstddeclib.c
tests/kvm-unit-tests/
tests/qemutests/
src/floppy.js/ contains parts ported from qemu under the MIT license, see LICENSE.MIT.

Credits

CPU test cases via QEMU
More tests via kvm-unit-tests
zstd support is included for better compression of state images
Berkeley SoftFloat is included to precisely emulate 80-bit floating point numbers
The jor1k project for 9p, filesystem and uart drivers
WinWorld sources of some old operating systems
OS/2 Museum sources of some old operating systems
ArchiveOS sources of several operating systems