What makes session-to-post notable?

1.7K downloads. Trust evidence available

How should session-to-post be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

session-to-post

Converts a Claude Code session into a blog post, case study, or Reddit post Skill: session-to-post Owner: athola Summary: Converts a Claude Code session into a blog post, case study, or Reddit post Tags: latest:1.9.19 Version history: v1.9.19 | 2026-08-26T13:21:54.947Z | user Release v1.9.19 v1.9.17 | 2026-07-30T05:41:51.213Z | user Release v1.9.17 v1.9.16 | 2026-07-14T19:58:39.686Z | user Release v1.9.16 v1.9.14 | 2026-06-30T18:06:20.539Z | user Release v1.9.14 v1.9.13 | 2026-06-27T16:24:03

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.7k

Updated

Oct 10, 2026

Version

1.9.19

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.7K downloads reported by the source. Last updated 10/10/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 10, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 10, 2026
Adoption signal: 1.7K downloadsadoption · observed Oct 10, 2026
Latest release: 1.9.19release · observed Aug 26, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17emme0e2m3cpf7k2jvp3a84984b8z9:nm-scribe-session-to-post

Setup complexity is classified as HIGH. You must provision dedicated cloud infrastructure or an isolated VM. Do not run this directly on your local workstation.
Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-athola-nm-scribe-session-to-post/snapshot"

Documentation

CLAWHUB

144,458 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: session-to-post
description: Converts a Claude Code session into a blog post, case study, or Reddit post
version: 1.9.8
triggers:
  - blog
  - marketing
  - session-capture
  - case-study
  - storytelling
  - developer-experience
  - reddit
  - publishing dev blog content or community posts from real sessions
metadata: {"openclaw": {"homepage": "https://github.com/athola/claude-night-market/tree/master/plugins/scribe", "emoji": "\ud83e\udd9e", "requires": {"config": ["night-market.scribe:shared", "night-market.scribe:slop-detector"]}}}
source: claude-night-market
source_plugin: scribe
---

> **Night Market Skill** — ported from [claude-night-market/scribe](https://github.com/athola/claude-night-market/tree/master/plugins/scribe). For the full experience with agents, hooks, and commands, install the Claude Code plugin.


# Session to Post

Capture what happened in a Claude Code session and turn it into a
blog post, case study, or social media thread that others can learn from.

The skill extracts the real story from git history, file changes, and
conversation context, then shapes it into a narrative that shows
process, not just results.

## When To Use

- After completing a meaningful chunk of work you want to share
- Creating dev blog content from real sessions
- Building case studies for tools, libraries, or techniques
- Producing marketing content that demonstrates capability
- Documenting a process for teammates who weren't in the session
- Sharing a session story with a Reddit community (r/programming,
  r/rust, r/Python, r/ClaudeAI, etc.)

## When NOT To Use

- Writing API reference documentation (use `scribe:doc-generator`)
- Creating step-by-step tutorials (use `scribe:tech-tutorial`)
- Cleaning up existing prose (use `scribe:slop-detector`)
- Internal project documentation (use `sanctum:doc-updates`)

## Integration Points

This skill connects to several others in the ecosystem.
Use them when the post needs more than prose.

| Need | Skill | What it adds |
|------|-------|-------------|
| Terminal demo GIF | `scry:vhs-recording` | Record a build/test run as an animated GIF |
| Browser demo GIF | `scry:browser-recording` | Capture a web UI walkthrough via Playwright |
| Composite media | `scry:media-composition` | Stitch terminal and browser GIFs side-by-side |
| Proof of claims | `imbue:proof-of-work` | Verify every number in the post with evidence |
| Code quality narrative | `pensive:code-refinement` | Describe what was cleaned up and why |
| Review narrative | `imbue:structured-review` | Capture review findings as post content |
| Change summary | `imbue:catchup` | Summarize what changed for the post's "The Work" section |
| Diff analysis | `imbue:diff-analysis` | Risk-scored change breakdown for technical audiences |

### Recording Integration (scry)

When the post describes something visual (a running app, a test suite,
a build pipeline) capture it instead of describing it.

**Terminal recordings** (build output, test runs,

_meta.json

{
  "ownerId": "kn7d107jg9jv602h9ytsegydq184a42s",
  "slug": "nm-scribe-session-to-post",
  "version": "1.9.19",
  "publishedAt": 1787750514947
}

modules/narrative-structure.md

---
module: narrative-structure
category: writing-quality
dependencies: []
estimated_tokens: 450
---

# Narrative Structure

Templates and patterns for turning a session brief into a post.

## Post Formats

### Blog Post (default)

Best for: dev blogs, company engineering blogs, personal sites.

```markdown
# [Verb]ing [What] [With/In/Using What]

[2-3 sentence opener. State what was done and the headline result.
No "In this post we will...": just say the thing.]

## Where We Started

[Concrete starting state. Numbers, not adjectives.
"A 150K-line C codebase" not "a large legacy codebase."]

## What We Built

### [Phase/Decision 1 name]

[What and why. 2-4 sentences. Code snippet only if it
illustrates a technique worth sharing.]

### [Phase/Decision 2 name]

[Same pattern. Focus on the interesting parts; skip
anything a reader could guess.]

![Terminal recording of tests passing](assets/tests.gif)

## How We Verified It

[Show the proof. Test output, before/after measurements,
screenshots. This is where recordings from scry belong.]

![Browser recording of the running app](assets/demo.gif)

## Results

| Metric | Before | After |
|--------|--------|-------|
| Lines of code | 0 | 10,950 |
| Tests passing | 0 | 180 |
| Build target | Emscripten | wasm-pack |

## What's Left

[Honest list. Readers respect knowing what isn't done.]

- [ ] Remaining item 1
- [ ] Remaining item 2
```

### Case Study

Best for: marketing, demonstrating tool capability to prospects.

```markdown
# [Outcome]: [How]

## The Challenge

[1 paragraph. What problem needed solving and why it was hard.]

## The Approach

[Walk through the method. Emphasize decisions, not steps.
Show how the tool/technique enabled the outcome.]

## The Evidence

[Hard numbers. Before/after. Screenshots and recordings.]

## Key Takeaways

1. [Insight that generalizes beyond this project]
2. [Insight about the tool or technique]
3. [What would change if doing it again]
```

### Social Thread

Best for: Twitter/X, Bluesky, LinkedIn.

```
1/ [Hook: the result in one sentence]

2/ Starting point: [concrete state before]

3/ The approach: [key technique in 1-2 sentences]

4/ [The interesting part: a decision, a pivot, a surprise]

5/ Results: [numbers]

6/ What's next: [honest assessment]

[Attach: GIF from scry recording, screenshot of output]
```

## Writing Rules

1. **Lead with the result**, not the process
2. **One number per section** minimum: ground every claim
3. **Show, don't summarize**: a GIF of tests passing says more
   than "we wrote comprehensive tests"
4. **Name the tools**: readers want to know how, not just what
5. **Include a pivot**: straight-line success stories aren't
   believable or interesting
6. **End with honesty**: what's unfinished, what you'd change

## Title Patterns That Work

- `[Verb]ing [Big Thing] in [Constraint]`
  e.g. "Porting a Game Engine to Rust in One Session"
- `How We [Achieved Result] with [Tool/Technique]`
  e.g. "How We Hit 180 Tests in 3 Hours with Para

modules/reddit-format.md

---
module: reddit-format
category: writing-quality
dependencies: []
estimated_tokens: 530
---

# Reddit Post Format

Templates and rules for turning a session brief into a Reddit
text post that earns upvotes through specificity and honesty.

## When Reddit, When Blog

Choose Reddit when:
- You want community engagement (questions, discussion, feedback)
- The work fits a specific subreddit's current interests
- The story is worth starting a conversation, not just archiving

Choose blog when:
- You want permanent, search-indexed content you own
- The post will be linked from documentation or READMEs
- It needs a stable URL for future reference

## Subreddit Targeting

Match the primary technology or theme to one subreddit. Avoid
cross-posting within 48 hours; it triggers spam filters and
community backlash.

| Subreddit | When to post |
|-----------|-------------|
| r/programming | general software development stories |
| r/rust | Rust code, tooling, ecosystem |
| r/Python | Python projects, libraries, tools |
| r/webdev | web development, frontend, full stack |
| r/devops | infrastructure, CI/CD, deployment |
| r/ClaudeAI | Claude Code usage, AI-assisted dev |
| r/ExperiencedDevs | technical depth, process, architecture |
| r/MachineLearning | ML systems, training, inference |

## Post Structure

Reddit text posts have no required format, but this pattern
works for session stories:

**Hook** (first 2 sentences): the most interesting outcome
or observation. Do not bury the lede. Readers who stop
scrolling past line 3 are gone.

**Context** (1-2 sentences): what you were trying to do and why.

**The work** (2-4 paragraphs): what you built or changed. Name
the tools and techniques. Include one code block if it shows
something surprising or non-obvious.

**Result**: numbers. What works now that did not before.

**Honest close**: what remains, what you would change, what
surprised you. This is what makes the post worth bookmarking.

---

**TL;DR** (required): the whole story in 2-3 sentences. Place
it after a `---` separator at the bottom. Readers who skip to
the end first are your secondary audience; do not disappoint them.

## Title Patterns

The title is the entire hook. Test it with: "would someone
who knows nothing about this click it?"

- `I [did thing] with [tool] — here's what I learned`
- `Built [thing] in [constraint] — [surprising number]`
- `[Surprising result]: how we [achieved it]`
- `Show r/[subreddit]: [what you built] ([brief description])`
- `[Honest take on tool] after [real production use case]`

Keep under 120 characters. The title must work without the body.

## Writing Rules

1. **First person**: "I built" not "we built" unless the team
   matters to the story
2. **No section headers** for posts under 600 words; above that,
   use one level of bold headers only
3. **One code block maximum** in the body; link the rest to
   a repo or Gist
4. **TL;DR is required**: after `---`, at the end
5. **Under 600 words** for most posts; if

modules/session-extraction.md

---
module: session-extraction
category: data-gathering
dependencies: []
estimated_tokens: 400
---

# Session Extraction Checklist

Run these commands and capture the output. This is the raw
material the narrative is built from.

## Git History

```bash
# Commits this session (adjust date/hash as needed)
git log --oneline --stat HEAD~20..HEAD

# Files changed summary
git diff --stat <start_commit>..HEAD

# Diff size
git diff --shortstat <start_commit>..HEAD
```

Capture: commit messages, files touched, insertions/deletions.

## Codebase Metrics

```bash
# Lines of code (adjust extension for language)
find . -name "*.rs" -not -path "*/target/*" | xargs wc -l | tail -1
find . -name "*.py" -not -path "*venv*" | xargs wc -l | tail -1
find . -name "*.ts" -not -path "*node_modules*" | xargs wc -l | tail -1

# File count
find . -name "*.rs" -not -path "*/target/*" | wc -l

# Test count
cargo test 2>&1 | grep "test result"
# or: pytest --co -q 2>&1 | tail -1
# or: npm test 2>&1 | grep "Tests:"
```

Capture: total lines, file count, test count and pass/fail.

## Architecture

```bash
# Directory tree (depth 3)
find . -type d -not -path "*/target/*" -not -path "*node_modules*" \
  -maxdepth 3 | sort

# Key config files
cat Cargo.toml  # or package.json, pyproject.toml
```

Capture: project structure, dependency count, crate/package organization.

## Build and Runtime

```bash
# Build output (note timing)
time cargo build --release 2>&1 | tail -5

# Binary/artifact size
ls -lh target/release/*.wasm dist/*.html 2>/dev/null
```

Capture: build time, artifact sizes.

## Conversation Context

These come from the session itself, not from commands:

- **Initial goal**: what the user asked for
- **Constraints**: time, tech stack, compatibility requirements
- **Key decisions**: why X over Y at each fork
- **Pivots**: where the plan changed and why
- **Blockers hit**: what went wrong and how it was resolved
- **Tools used**: parallel agents, specific skills invoked

## Output Format

Compile extraction results into a structured brief:

```markdown
## Session Brief

**Goal**: [one sentence]
**Duration**: [approximate]
**Starting state**: [what existed before]

### Metrics
- Lines written: X
- Files created/modified: Y
- Tests: Z passing

### Key commits
1. [hash] [message]: [significance]
2. ...

### Decisions
1. [decision] because [reason]
2. ...

### Pivots
1. [what changed] because [what happened]
2. ...
```

Github ReposUpdated 15h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.