cklxx

Control message formatting and writing style for Lark/Feishu conversations.

Create, query, edit, and manage Feishu Bitable (multidimensional spreadsheets) via lark-cli base — apps, tables, fields, records, views, dashboards, forms, workflows.

Manage Feishu calendar events via lark-cli — create/update/delete events, manage attendees, query free/busy and suggest available time slots, find and book meeting rooms.

List Feishu group chat members and resolve chat metadata via lark-cli.

Create a Feishu cloud document from Lark-flavored Markdown via lark-cli, with optional folder or wiki placement.

Comment management and media (image/file) operations on Feishu cloud documents via lark-cli.

Manage files in Feishu Drive via lark-cli — list, upload, download, copy/move/delete, comments, permissions, import/export, and bulk sync.

Fetch Feishu cloud document content as Lark-flavored Markdown via lark-cli. Media (images/files/whiteboards) are token references that must be downloaded separately.

When prompt, tool, or agent logic changes need regression testing → run eval benchmarks to detect regressions or improvements.

When a task can be parallelized (bulk code review, multi-module refactor, batch analysis) → split into subtasks running in isolated git worktrees via multiple workers.

When the user wants to research academic papers → search ArXiv, extract PDFs, summarize/review/Q&A, generate experiment code.

When you need to interact with web pages using the user's logged-in browser → control Chrome via @playwright/cli daemon, reusing cookies/session with persistent tabs.

When user needs AnyGenIO content generation → unified CLI for task execution with progressive disclosure.

When you need to persist files (reports, docs, evidence) beyond the session → create/query/delete durable artifacts.

When the user wants text-to-speech audio → generate voice files locally (macOS say + afconvert, outputs m4a).

When a repeated workflow should be codified as a reusable skill → auto-create skill files, optionally using Codex/Claude.

Use when a VERIFIED, DURABLE insight emerges — not raw events (that's recording-practices), not pattern analysis (that's running-retros). Persists one-line knowledge items to docs/memory/long-term.md, which is loaded on every session start.

Use DURING work when a notable event occurs — bug fixed, non-obvious root cause found, effective technique discovered, pitfall hit. Logs raw experience entries. Does NOT distill rules (that's running-retros) or persist knowledge (that's managing-memory).

Use when enough raw experience has accumulated to compress — 10+ unreviewed entries, milestone completed, or 7+ days since last retro. Reads entries, finds patterns, distills executable rules, and feeds them back into memory. This is the compression step that turns raw logs into curated knowledge.

Bootstraps compound-engineering on every session. Loads project memory, scans recent experience, and activates the plan→record→remember→review loop.

Use BEFORE starting non-trivial work. Creates a structured plan with task breakdown, technical design, and risks. A task is non-trivial if it touches 3+ files, involves a design choice, or will take more than 30 minutes.

Use this skill when ckl asks to ground an ARLE serving/runtime, model-path, benchmark, capacity, Qwen3.5/DeepSeek, scheduler, paged_kv, MLX, autograd, or OPD decision in upstream SGLang/vLLM/TensorRT-LLM evidence before changing local code. It distills BBuf AI-Infra Auto Driven SKILLS into an ARLE-specific source-survey workflow without symlinking or vendoring those repositories.

Use this skill when ckl asks to optimize an ARLE kernel, operator, attention path, GEMM, decode/prefill path, quantization op, scheduler hot path, TTFT/ITL/tok-s metric, memory footprint, or any "optimize this operator" / "tune the kernel" / "make this faster" request. It enforces formula-predict -> measured binding constraint -> matched single-variable A/B -> interaction A/B when needed -> explicit tradeoff -> license-or-kill, and keeps the industry catalog scoped to ARLE CUDA/TileLang/MLX/runtime work.

Use this skill when ckl asks to inspect, queue work for, interrupt, spawn, replace, or otherwise drive another coding-agent CLI running inside tmux. Covers ARLE's known-safe tmux path for Codex/Claude Code delegation, including session discovery, capture-pane status checks, Enter semantics, long-brief buffer paste, queue-vs-immediate behavior, and don't-send-to-yourself safety.

Use this skill BEFORE writing code for any task you're tempted to call "hard / tough / complex", any "why is X slow / where's the bottleneck", any "should I optimize Y", any concurrency/perf/kernel/scheduler investigation, or any time you catch yourself hand-waving a root cause. It is the pre-implementation understanding GATE — decompose to the atomic (line/kernel/buffer) level, get MEASURED evidence, let measurement correct your hypotheses, until the problem is SIMPLE and quantified. Only then write code. If it still feels hard, you haven't decomposed enough.

Use when editing TileLang C++ passes or TVM TIR code that handles ObjectRef/NodeRef types such as For, Buffer, Var, Block, Stmt, PrimExpr, or their *Node raw node counterparts; especially when choosing function parameters, optional values, identity maps/sets, or equality checks.