Build With Public Writer

Build with Public - Technical Blog Writing System

Overview

This skill helps you establish a complete Build with Public technical blog writing workflow. From directory architecture setup, Git version management, multi-angle writing approach design, to final article link sharing, it provides end-to-end toolchain support.

Core Value:

• 🏗️ Standardized blog project architecture
• 📝 Systematic multi-angle writing process
• 🔄 Versioned iteration management mechanism
• 🌐 Instant link sharing capability

When to Use

When you need to:

• Establish a personal technical blog writing workflow
• Systematically manage multi-version technical articles
• Build technical influence through public building
• Solidify the writing process into reusable assets

Prerequisites

• Python 3.11+
• Git
• An accessible domain or IP (for link sharing)

Workflow

Phase 1: Project Initialization

Step 1: Determine Project Name

Confirm the blog project name with the user (e.g., codewithriver, techblog, buildinpublic, etc.):

Suggested name: codewithriver
Suggested name: tech-notes
Suggested name: buildlog

Step 2: Create Directory Architecture

mkdir -p ~/{project-name}/{articles,draft,images,logs,tweets}
cd ~/{project-name}

Standard Directory Structure:

{project-name}/
├── articles/          # Published articles (version managed)
│   ├── 2026-03-02-topic-v1.md
│   ├── 2026-03-02-topic-v2.md
│   └── ...
├── draft/             # Writing outlines and drafts
│   ├── 2026-03-02-topic-outline-01.md
│   └── ...
├── images/            # Article images
├── logs/              # Writing logs
├── tweets/            # Promotional copy
├── .env               # Configuration (port, password, domain)
├── server.py          # Web server
└── .git/              # Version control

Step 3: Initialize Git Repository

cd ~/{project-name}
git init
git config user.email "your@email.com"
git config user.name "your-name"

Step 4: Create Web Server

Create server.py:

#!/usr/bin/env python3
"""Build with Public - Web Server"""

import os
import mimetypes
from functools import wraps
from flask import Flask, send_file, render_template_string, abort, request, Response
from pathlib import Path
from dotenv import load_dotenv

load_dotenv()

app = Flask(__name__)

CONTENT_DIR = Path(os.environ.get('CONTENT_DIR', os.getcwd()))
PORT = int(os.environ.get('PORT', 12000))
HOST = os.environ.get('HOST', '0.0.0.0')
AUTH_PASSWORD = os.environ.get('AUTH_PASSWORD', 'openskill')
AUTH_USERNAME = os.environ.get('AUTH_USERNAME', 'user')

# [Server code template, full implementation omitted here]
# Full code reference: templates/server.py.template in skill package

def check_auth(username, password):
    return username == AUTH_USERNAME and password == AUTH_PASSWORD

def requires_auth(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        auth = request.authorization
        if not auth or not check_auth(auth.username, auth.password):
            return Response('Authentication required', 401, {'WWW-Authenticate': 'Basic realm="BuildWithPublic"'})
        return f(*args, **kwargs)
    return decorated

@app.route('/')
@requires_auth
def index():
    # [Directory listing implementation]
    pass

@app.route('/<path:subpath>')
@requires_auth
def serve_path(subpath):
    # [File serving implementation]
    pass

if __name__ == '__main__':
    print(f"🚀 Server starting on http://{HOST}:{PORT}")
    app.run(host=HOST, port=PORT, debug=False)

Step 5: Create .env Configuration File

cat > .env << 'EOF'
# Build with Public - Configuration
PORT=12000
HOST=0.0.0.0
AUTH_USERNAME=user
AUTH_PASSWORD=openskill
CUSTOM_DOMAIN=your-domain.com
EOF

Step 6: Start Server and Commit

# Install dependencies
pip install flask python-dotenv

# Start server
python server.py &

# Initial commit
git add .
git commit -m "[$(date +%Y-%m-%d)] init: Initialize Build with Public writing system"

Phase 2: Writing Requirements Analysis (with Completeness Check)

Requirements Completeness Assessment

Before officially starting, assess whether the information provided by the user is sufficient. Check the following required items:

Criteria:

• ✅ Sufficient Information (≥6 items clear) → Proceed to Phase 3
• ⚠️ Partially Missing (4-5 items clear) → Ask for missing items, can continue
• ❌ Severely Insufficient (≤3 items clear) → Must supplement before continuing

Follow-up Strategy

When conditions are vague, use progressive questioning:

Round 1 (Topic Focus):

The "{topic}" you mentioned is quite broad. To provide a precise writing plan,
could you tell me:
1. What specific tech stack/tools are involved?
2. Do you want to write a tutorial (How-to) or experience sharing (Lesson-learned)?
3. What's the approximate technical level of the readers?

Round 2 (Deep Dive):

Thanks for the details! To make the plan more fitting, I'd like to know:
1. How much hands-on experience do you have in this area? (Affects article credibility positioning)
2. Are there any technical difficulties or pitfalls you want to emphasize?
3. What do you expect readers to gain after reading? (Learn skills/Avoid pitfalls/Understand principles)

Round 3 (Feasibility Confirmation):

Finally, confirm two details:
1. How long do you want the article to be? (Affects structure depth)
2. When do you expect to publish? (Affects iteration count)

Minimum Viable Conditions (MVP)

Even if information is incomplete, the following 4 items are required, otherwise cannot start:

1. ✅ Writing Topic - What to write?
2. ✅ Target Audience - Who to write for?
3. ✅ Core Goal - What to achieve?
4. ✅ Technical Background - What technology is involved?

If any of the above is missing, must ask for clarification.

Step 1: Deep Understanding of Writing Topic

After sufficient information, further clarify:

Topic Dimension Analysis:

• Technical Depth: Principle level / Application level / Tool level?
• Time Dimension: Historical review / Current analysis / Future outlook?
• Practice Dimension: Pure theory / With examples / Complete tutorial?

Example Comparison:

Step 2: Quality Goal Setting

Confirm quality expectations with the user:

Phase 3: Multi-Angle Approach Design

Based on the writing topic, design 3-5 different writing angles.

Common Angle Templates

Output Outline Files

Create outline files for each angle:

# File naming format: {date}-{topic}-{angle}-outline.md
# Examples:
# 2026-03-02-skill-explorer-tutorial-outline.md
# 2026-03-02-skill-explorer-case-study-outline.md

Outline Content Structure:

# Outline Option: {Angle Name}

**Date**: YYYY-MM-DD
**Title**: "Article Title"

## Core Viewpoint
- One sentence summarizing the core argument

## Outline Structure
1. **Introduction**: Introduce problem and value
2. **Part One**: ...
3. **Part Two**: ...
4. **Conclusion**: Summary and outlook

## Target Audience
- Reader persona description

## Estimated Word Count
- XXXX words

## Keywords
keyword1, keyword2, ...

Save to draft Directory

# Example
draft/
├── 2026-03-02-skill-explorer-tutorial-outline.md
├── 2026-03-02-skill-explorer-case-study-outline.md
├── 2026-03-02-skill-explorer-methodology-outline.md
└── ...

Phase 4: User Selection and Confirmation

Present options for user selection:

## Available Writing Approaches

### Approach 1: Tutorial ⭐Recommended
- **Title**: "From Scratch: How to Build XXXX"
- **Features**: Clear steps, beginner-friendly
- **Estimate**: 4000 words, 25-minute read

### Approach 2: Hands-on Experience
- **Title**: "How I Solved XXXX in One Week"
- **Features**: Real case, pitfall guide
- **Estimate**: 3500 words, 20-minute read

### Approach 3: Deep Analysis
- **Title**: "The Architecture Design Behind XXXX"
- **Features**: Technical depth, principle analysis
- **Estimate**: 5000 words, 30-minute read

**Please select** (or request adjustments): ...

After user confirmation, proceed to writing phase.

Phase 5: Article Writing

Version Numbering Rules

Use semantic versioning:

File Naming Convention

{date}-{topic}-{slug}-v{version}.md

Examples:
- 2026-03-02-skill-explorer-tutorial-v1.md
- 2026-03-02-skill-explorer-tutorial-v2.md
- 2026-03-02-skill-explorer-tutorial-v2.1.md

Writing Process

1. Create v1.0

   # Create first draft based on selected outline
   cat > articles/2026-03-02-topic-v1.md << 'EOF'
   # Article content
   EOF
   

2. Iterative Optimization

   • Create v1.1, v1.2... based on feedback
   • Upgrade to v2.0 for major adjustments

3. Commit to Git After Each Modification

   git add articles/
   git commit -m "[YYYY-MM-DD] v{X.Y}: Modification description"
   

Phase 6: Link Sharing

After article completion, provide access link:

Article link: http://your-domain.com:12000/articles/2026-03-02-topic-v2.md

Default Information for Sharing:

• Access requires password (default: openskill)
• Browser will remember password
• Supports direct Markdown file download

Best Practices

Git Commit Convention

# Format
[Date] Type: Description

- Change detail 1
- Change detail 2

# Types
feat:    New article/new feature
fix:     Error correction
docs:    Documentation update
refactor: Refactoring/renaming
style:   Format adjustment

Version Control Strategy

• Minor changes (typos, formatting): Don't upgrade version number, overwrite directly
• Content optimization (paragraph adjustment, detail supplement): v1.0 → v1.1
• Structure adjustment (outline change, angle conversion): v1.x → v2.0

Directory Maintenance

Regular cleanup:

• Deprecated outlines in draft/
• Outdated versions in articles/ (keep latest 2-3 versions)

Output Templates

Approach Selection Display Template

## 📝 Writing Approach Options

Based on your requirement "{topic}", I've designed {N} writing angles:

### Approach 1: {Angle Name}
**Title**: "{Suggested Title}"
**Core Viewpoint**: {One sentence summary}
**Target Audience**: {Reader persona}
**Estimated Length**: {word count} words
**Outline Points**:
1. {Point 1}
2. {Point 2}
3. {Point 3}

---

[Approach 2, 3 ...]

## Please Select

Reply with a number (1/{N}) to select an approach, or tell me what adjustments are needed.

Article Completion Notification Template

✅ Article completed!

**Version**: v{X.Y}
**File**: articles/{filename}
**Word Count**: {N} words
**Access Link**: http://{domain}:12000/articles/{filename}

**Access Password**: openskill

**Version History**:
- v1.0: First draft complete
- v1.1: Expression optimization
- v2.0: Structure adjustment
- v{X.Y}: Current version

If modifications are needed, please specify requirements.

Examples

Example 1: Skill Explorer Article Series

Project: codewithriver
Topic: skill-explorer skill development
Output:

• draft/2026-03-02-skill-explorer-tutorial-outline.md
• draft/2026-03-02-skill-explorer-case-study-outline.md
• draft/2026-03-02-skill-explorer-methodology-outline.md
• articles/2026-03-02-skill-explorer-tutorial-v1.md
• articles/2026-03-02-skill-explorer-tutorial-v2.md
• articles/2026-03-02-skill-explorer-tutorial-v2.1.md
• articles/2026-03-02-skill-explorer-tutorial-v2.2.md

Related Skills

• skill-explorer: Evaluate and select ClawHub skills
• tweet-writer: Write promotional copy
• marketing-mode: Develop content marketing strategy

Tips

1. Keep iterating: Good articles are refined through revisions, don't fear version number increases
2. Commit promptly: Commit every meaningful change to Git
3. Try multiple angles: Different angles on the same topic may attract different readers
4. Share via links: Cultivate the habit of sharing links rather than full text, train reader access habits

Build with Public - Make Your Technical Growth Visible

Appendix B: Xiaohongshu Platform Adaptation Guide

Why Platform Adaptation is Needed

The same technical content can be published to multiple platforms, but each platform has different user habits and content formats.

Platform Comparison:

• Technical Blog: Professional developers, in-depth long articles, 3000-8000 words
• Xiaohongshu: Young learners, casual short notes, 500-1500 words
• Twitter/X: Tech professionals, opinion threads, 280 chars/tweet
• WeChat Official Account: General tech audience, story-driven articles, 2000-5000 words

Xiaohongshu Platform Characteristics

1. Title Formula: [Emoji] + [Pain Point/Question] + [Solution] + [Emoji] + [Value Point]

Examples:

• 🦞 Too many OpenClaw skills to choose from? I mastered it in 8 steps! ✨
• 🔥 Must-see for programmers! OpenClaw skill explorer, say goodbye to pitfalls!
• 💡 One day from newbie to publishing first OpenClaw skill!

2. Content Structure Template:

• Opening pain point (golden 3 seconds)
• Solution introduction
• Step breakdown + emoji numbering
• Results showcase
• Bonus time
• Interaction guidance

3. Language Style Conversion:

• AI Agent → OpenClaw / AI Assistant
• Developer → Babes / Sisters
• Skill Assessment → Skill Selection Tips
• Systematic Process → 8 Steps to Master
• Experience Sharing → Tested and Proven

4. File Naming Convention:

{date}-{topic}-v{version}-xiaohongshu.md

Multi-Version Management Best Practices

1. First determine base version (v1.0/v2.0) technical blog version
2. Then derive platform version: cp topic-v2.md topic-v2-xiaohongshu.md
3. Rewrite content and style according to Xiaohongshu template
4. Independent iteration: Technical blog version and Xiaohongshu version managed separately

Quick Conversion Tips

Use sed command for batch term replacement:

sed -i 's/AI Agent/OpenClaw/g' article-xiaohongshu.md
sed -i 's/Developer/Babes/g' article-xiaohongshu.md

Phase 7: Version Management and Iteration

Git Workflow

Execute after each file change:

git add -A
git commit -m "[YYYY-MM-DD] vX.Y: Modification description"

Version Control Strategy

Multi-Version Parallel Management

Technical blog version and Xiaohongshu version iterate independently:

articles/
├── topic-v2.md              # Technical blog version
├── topic-v2.1.md            # Technical blog version iteration
├── topic-v2-xiaohongshu.md  # Xiaohongshu version
└── topic-v2.1-xiaohongshu.md # Xiaohongshu version iteration

Phase 8: Publishing and Promotion

Pre-Publishing Checklist

• Content complete, no typos
• Code tested
• Link accessible
• Git committed

Promotion Channels

1. Tech Communities: V2EX, Juejin, Zhihu
2. Social Media: Twitter, Xiaohongshu, WeChat Official Account
3. Open Source Platforms: GitHub, ClawHub

Interaction Strategy

• Pose interactive questions at article end
• Reply to comments, build connections
• Collect feedback, continuous iteration

Build with Public - Make Your Technical Growth Visible