write-tbp
Verifiedby tldraw · Updated Apr 16, 2026
Writing technical blog posts about tldraw features and implementation details. Use when creating blog content about how tldraw solves interesting problems.
See It In Action
The working directory is empty — there's no tldraw repo here. Let me clone it so we have actual source to ground the blog post in.
Let me read the key files in parallel to understand the architecture.
Now let me read the routing logic files:
Now let me read the remaining key files:
Now let me check the schema for arrow shapes:
Now let me look at the binding util and the ArrowShapeUtil for rendering:
Now let me check the binding util briefly:
I now have a thorough understanding of the codebase. Let me write the blog post and research notes.
Both files are ready in your working directory:
-
blog-post.md— publish-ready internal blog post (~1,500 words). Covers the three arrow types, elbow terminal resolution, edge usability via range subtraction, the three edge-picking strategies, the transform-based symmetry trick (4 functions → 16 combos), geometry casting, snap lines, and caching. Written for an engineering audience that knows tldraw but hasn't dug into the arrow internals. -
research-notes.md— structured reference with a file-by-file inventory, architecture diagram, key design decisions, all route variants with ASCII art from the source, thepickBestalgorithm, and performance notes.
Everything is grounded in the actual source — file paths, function names, data structures, and the ASCII diagrams are pulled directly from the repo.
Permissions
| Scope | Description |
|---|---|
| filesystem:read | |
| filesystem:write |
SKILL.md
Write technical blog post
This skill covers how to write technical blog posts about tldraw's implementation details.
Process
1. Create the workspace
Create an assets folder for this topic:
.claude/skills/write-tbp/assets/<topic>/
├── research.md # Gathered context and notes
└── draft.md # The blog post draft
Use a short, kebab-case name for the topic (e.g., scribbles, arrow-routing, dash-patterns).
2. Research the topic
Use an Explore subagent to gather all relevant information:
Task (subagent_type: Explore, thoroughness: very thorough)
Find all code, documentation, and context related to [TOPIC] in the tldraw codebase.
Look for:
- Implementation files in packages/editor and packages/tldraw
- Type definitions in packages/tlschema
- Related examples in apps/examples
- Any existing documentation in apps/docs/content
- Tests that reveal behavior
- Comments explaining why things work the way they do
For each relevant file, note:
- What it does
- Key functions/classes
- Interesting implementation details
- Any "why" comments or non-obvious decisions
Output a comprehensive summary of how [TOPIC] works. This document will be read by another agent. No need to over-optimize for human readability.
Save the research output to assets/<topic>/research.md.
3. Identify the interesting angle
Before writing, answer these questions from the research:
- What problem does this solve? Not "what does it do" but "what would go wrong without it?"
- What's surprising or unintuitive? The obvious approach that doesn't work, or the hidden complexity.
- What's the key insight? The "aha" that makes the solution work.
- What did we try first? Any journey or iteration visible in the code or comments.
If you can't find an interesting angle, the topic may not be suitable for a technical blog post.
4. Write the draft
Create assets/<topic>/draft.md following the blog-guide structure:
- Frame the problem — Hook the reader with context and tension
- Show the insight — The key idea that makes it work
- Walk through the implementation — Code and explanation, building complexity
- Wrap up — Where it lives, tradeoffs, links to files
Target 800-1500 words.
5. Self-evaluate
Check the draft against the blog-guide checklist:
- Opening — Does it frame a problem before diving into solution?
- Insight — Is there a clear "aha" moment or key idea?
- Specificity — Is this grounded in tldraw's actual implementation?
- Code — Do examples build understanding, not just show syntax?
- Tone — Warm and personal, but not rambling?
- Links — Points to actual code in the repo?
- Length — Appropriate depth for the topic?
Revise the draft to address any gaps.
6. Output
Present the final draft to the user for review. The draft remains in assets/<topic>/draft.md until the user is satisfied, at which point they can move it to the appropriate location.
References
- Style guide: See
../shared/blog-guide.mdfor voice, tone, and structure. - Writing guide: See
../shared/writing-guide.mdfor general writing conventions.
FAQ
What does write-tbp do?
Writing technical blog posts about tldraw features and implementation details. Use when creating blog content about how tldraw solves interesting problems.
When should I use write-tbp?
Use it when you need a repeatable workflow that produces downloadable file.
What does write-tbp output?
In the evaluated run it produced downloadable file.
How do I install or invoke write-tbp?
Ask the agent to use this skill when the task matches its documented workflow.
Which agents does write-tbp support?
Agent support is inferred from the source, but not explicitly declared.
What tools, channels, or permissions does write-tbp need?
It uses no extra tools; channels commonly include file; permissions include filesystem:read, filesystem:write.
Is write-tbp safe to install?
Static analysis marked this skill as medium risk; review side effects and permissions before enabling it.
How is write-tbp different from an MCP or plugin?
A skill packages instructions and workflow conventions; tools, MCP servers, and plugins are dependencies the skill may call during execution.
Does write-tbp outperform not using a skill?
About write-tbp
When to use write-tbp
When you want to turn a tldraw feature or internal implementation detail into a polished technical blog draft. When you need a repeatable workflow for researching code, extracting the key insight, and writing a post grounded in the repository. When you want blog assets organized into topic-specific research and draft files.
When write-tbp is not the right choice
When the task requires publishing the post to a CMS or external platform. When the topic is not based on the local tldraw codebase or lacks enough implementation detail for a technical post.
What it produces
Produces downloadable file.