Get AI summaries of any video or article — Sign up free
Daniele Procida - Always complete, never finished thumbnail

Daniele Procida - Always complete, never finished

Write the Docs·
6 min read

Based on Write the Docs's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Treat documentation as publishable at every stage: aim for “complete now” rather than “finished later.”

Briefing

Documentation work often gets trapped in long, detailed planning cycles that delay publishing and amplify anxiety—leaving teams with “work in progress” that’s out of date before it’s ever usable. Daniela Procida’s core claim is that documentation should be treated as “always complete, never finished”: it can be complete enough to publish at every stage, while still evolving continuously. That mindset matters because documentation isn’t a ship under construction; it’s a product need that becomes urgent the moment users require it.

Procida distinguishes the pain of necessary effort from the pain of avoidable frustration. Writing itself is usually manageable—turning knowledge into readable text. The real suffering comes from deciding what to document, in what order, how much to write, and when to stop, then restarting when plans fail. The deeper driver is the belief that nothing is valuable until the whole plan is executed. In complex documentation projects—especially during restructuring—plans become brittle: product details shift, other contributors commit changes, and entire sections can become obsolete mid-flight. The result is labor without reward: long stretches where nothing publishable exists, even though the product is “crying out” for documentation.

She argues that the planning trap is fueled by confusing “finished” with “complete.” A framework she’s associated with—often mistaken for a blueprint—should instead function as a guide for checking direction, not a mandate to produce a comprehensive plan. The alternative she proposes borrows from “well-formed growth” in living organisms. A plant grows in stages that are always appropriate to its size: each moment is structurally correct for where it is, even though it’s not mature yet. Applied to documentation, this means iterative evolution from the inside out: small, well-scoped improvements that immediately increase usefulness.

Her practical workflow is deliberately tiny. Pick something small already in hand—often a page, section, paragraph, or even a single word—critique it against documentation standards (especially user need, language, and logic), then choose one next action that produces an immediate improvement. Repeat the cycle quickly. This approach reduces the emotional burden of being responsible for unfinished work that won’t matter until a distant “finish line.” It also supports restructuring: transform content in place through incremental steps, postponing large transplant operations until the material is robust enough to survive.

Procida illustrates the method with two examples. For a new documentation project, she built documentation for a Python model of a 35mm film camera. Instead of drafting a full outline, she published early and iteratively—adding a “get started” proto tutorial, reference sections, test instructions, and expanding explanations as the code evolved. For restructuring, she describes prior failed attempts to reorganize pytest documentation using large refactoring-style plans. The successful shift came when she and the pytest community agreed to small commits and rapid review cycles, trusting that each incremental change would collectively evolve the structure. In both cases, the work felt “complete” at each stage—useful and coherent—while still clearly unfinished.

The takeaway is a workflow principle: optimize for completeness of each incremental step, not completion of a grand plan. By nurturing “frogs and French beans” rather than chasing delivery of a final form, teams can publish sooner, adapt to change, and reduce anxiety while improving documentation steadily.

Cornell Notes

Procida’s message is that documentation should be “always complete, never finished.” Teams often suffer when they treat documentation frameworks as blueprints for exhaustive plans, then delay publishing until everything is done. She reframes the work as iterative, organic growth: at any moment, documentation can be structurally “complete” for its current stage even if it isn’t mature. The practical method is to choose a very small unit already in hand, critique it against user needs and writing standards, then perform one next action that yields an immediate improvement. Repeating short cycles reduces the anxiety of unfinished work and helps restructuring succeed without risky, all-at-once refactors.

Why does planning create so much pain in documentation work?

Procida argues that the hardest part isn’t writing text—it’s deciding what to tackle, in what order, and when to stop. Detailed plans create a “finish line” mindset: until the whole plan is executed, the output feels unusable and therefore unrewarding. In complex or restructuring contexts, plans also become fragile: product details change, other contributors commit files, and sections can become obsolete before they’re publishable. That turns documentation into labor without reward, similar to a shipyard situation—except documentation is needed immediately by users.

What does “complete” mean if documentation is never “finished”?

She draws a distinction between “finished” (a final, mature end state) and “complete” (structurally appropriate and useful for its current stage). Using the analogy of living growth, a plant is always complete relative to its size and stage: it’s well formed now, even though it will grow further. Documentation can follow the same logic—publishable and coherent at each step—while continuing to evolve.

How does the “well-formed growth” model translate into a workflow?

The workflow is iterative evolution from the inside out. Instead of building a grand plan, work in small cycles: take something small already available (a page, section, paragraph, or even a single word), critique it against documentation standards (user need, language, logic), then identify one next action that produces an immediate improvement. Do that one action, then repeat. The goal is tiny, frequent progress that keeps documentation useful and reduces anxiety.

How does this approach help with restructuring existing documentation?

Restructuring often fails when treated like a large refactor that must be finished before anything is useful. Procida recommends transforming content in place through incremental steps, minimizing dramatic refactoring. By evolving structure gradually, teams can postpone larger “transplanting” only until the material is robust enough to survive. She also notes that documentation refactoring can be harder to validate than code refactoring because broken logic flow may not trigger automated tests.

What real-world examples support the method?

For new documentation, she describes building documentation for a Python model of a 35mm film camera. She avoided planning a full outline and instead published early and often, adding sections as the project matured (e.g., “get started,” reference material, test instructions, and expanded explanations), eventually splitting content into multiple pages in a Sphinx-powered documentation set. For restructuring, she recounts earlier failed attempts to reorganize pytest documentation using large, plan-driven refactors (including efforts around EuroPython sprints). The successful version relied on small commits, quick pull request cycles, and community trust that each incremental change would collectively evolve the structure.

How can teams get buy-in for incremental restructuring when people expect upfront plans?

Procida suggests that consensus-building and trust matter more than detailed upfront planning. She describes gaining confidence by talking with people and aligning on a process where small commits will be reviewed and merged quickly. The key is making it clear that the work will proceed in coherent micro-steps, so contributors can accept that the documentation will improve continuously rather than waiting for a comprehensive end-state.

Review Questions

  1. How does the “complete vs finished” distinction change what counts as progress in documentation?
  2. Describe Procida’s small-cycle workflow. What are the inputs, the critique criteria, and the output of each cycle?
  3. Why did large refactoring-style restructuring attempts fail for pytest, and what process change made the incremental approach succeed?

Key Points

  1. 1

    Treat documentation as publishable at every stage: aim for “complete now” rather than “finished later.”

  2. 2

    Avoid converting documentation frameworks into exhaustive blueprints; use them as guides for direction and evaluation.

  3. 3

    Identify the real source of documentation pain: planning that delays usefulness and creates brittle expectations.

  4. 4

    Use tiny iterative cycles: critique a small unit already in hand and perform one next action that yields an immediate improvement.

  5. 5

    For restructuring, evolve content in place through incremental transformations rather than large refactors that must be completed before merging.

  6. 6

    Build trust through rapid review and small pull requests, especially when restructuring requires buy-in from maintainers.

  7. 7

    Measure success by usefulness gained quickly and consistently, not by reaching a distant final plan.

Highlights

Documentation becomes less stressful when each step is “complete” enough to publish, even if it’s not mature.
The planning trap comes from confusing “finished” with “complete,” then waiting for a finish line that may never arrive on time.
Incremental restructuring works when small commits are reviewed and merged quickly, letting structure evolve naturally over time.
Publishing early and often—adding sections as knowledge and code mature—keeps documentation useful instead of stuck as work in progress.

Topics

  • Always Complete Never Finished
  • Iterative Documentation
  • Well-Formed Growth
  • Restructuring by Small Commits
  • Documentation Planning Traps

Mentioned

  • Daniela Procida