stindardlogic/technical-writing-sft-100k

Technical Writing SFT (100K)

100,000 ShareGPT conversations demonstrating high-quality technical writing across 20 document types. Each example produces a complete, professional technical document — from API reference to architecture decision records to runbooks — written in the style that experienced technical writers and senior engineers actually use.

Motivation

Technical writing is one of the most underserved capabilities in LLMs. Common model failures:

• Wrong format for the document type: Producing a narrative README when the reader needs a quick-start + API table, or producing a bullet-point ADR when the reader needs reasoned prose
• Missing the audience: Writing a migration guide in abstract terms when developers need exact command-line instructions and diff examples
• Over-explaining the obvious: Spending paragraphs on what instead of why — the reader already knows what it is; they need to know what changed, what breaks, and what to do
• Inconsistent structure: Each section has different formatting conventions, violating the reader's mental model
• No "signal-to-noise" discipline: Long preambles, excessive caveats, and summary sections that repeat what was just said

This dataset trains models to produce technical documents that engineers actually want to read: structured, scannable, precise, and calibrated to the reader's existing knowledge.

Dataset Description

100,000 conversations across 20 document types:

Document Type	Description
readme	Library/tool READMEs with quick-start, installation, API reference, examples
changelog	Structured changelogs with semantic versioning, migration notes, deprecations
api_reference	Endpoint documentation with request/response schemas, examples, error codes
technical_spec	System design specs with requirements, architecture, trade-off analysis
setup_guide	Step-by-step environment setup with prerequisites, verification, troubleshooting
template	Reusable document templates (post-mortems, PRDs, ADRs, etc.)
docstring	Google/NumPy/reST style docstrings with args, returns, raises, examples
migration_guide	Version migration guides with breaking changes, code diffs, before/after
runbook	Operational runbooks for alerts and incidents with diagnosis and remediation steps
architecture_decision_record	ADRs with context, decision, consequences, alternatives considered
style_guide	Writing and coding style guides with examples and anti-patterns
onboarding_guide	Team onboarding documentation with context, setup, first-week guidance
user_story	Agile user stories with acceptance criteria and definition of done
data_dictionary	Database/schema documentation with field descriptions, types, constraints
product_requirements	PRDs with problem statement, requirements, success metrics
contributing_guide	OSS contributing guides with development setup, PR process, code standards
deprecation_notice	API/feature deprecation notices with migration paths and timelines
system_design	High-level system design documents with components, scaling, trade-offs
checklist	Technical process checklists (security review, deployment, code review)
blog_post	Technical blog posts explaining architecture decisions or engineering concepts

Format

{
  "conversations": [
    {
      "from": "human",
      "value": "Write a README for a Python library called vectorstore that provides a simple interface for storing and querying document embeddings..."
    },
    {
      "from": "gpt",
      "value": "# vectorstore\n\nA lightweight Python library for storing and querying document embeddings...\n\n## Installation\n\n```bash\npip install vectorstore\n```..."
    }
  ],
  "metadata": {
    "doc_type": "readme",
    "domain": "developer_tools"
  },
  "id": "abc123"
}

Key Properties of Responses

1. Document-type-appropriate structure: READMEs have quick-start + reference tables. Runbooks have numbered steps with verification commands. ADRs have context + decision + consequences. Structure serves the reader's workflow.

2. Scannable formatting: Technical readers scan before they read. Headers, code blocks, tables, and lists are used to support scanning — not decoration.

3. Precise and complete: API references include all fields, types, and edge cases. Migration guides include exact command-line steps. Setup guides include verification steps for each stage.

4. Calibrated specificity: Documents include realistic technical details — actual library names, realistic version numbers, plausible error messages, real command-line syntax.

5. The "why" surfaces in the right places: Architecture documents explain rationale. Changelogs explain the motivation for breaking changes. READMEs explain what problem the library solves — not just what it does.

6. Anti-patterns avoided: No "This document describes..." preambles. No "In conclusion..." summaries. No passive voice where active voice is clearer. No vague verbs ("it handles", "it manages") where precise ones are available.

Use Cases

• SFT fine-tuning for AI coding assistants that help with documentation (GitHub Copilot, Cursor)
• Training AI documentation generators for software projects
• Building AI writing assistants for engineering teams
• Improving model performance on technical writing benchmarks
• Training models for developer experience (DX) tools
• Fine-tuning models for API documentation generation and maintenance

License

Apache 2.0