Documentation

5 posts

toss3 min readCurated summary

Why Does Our Team’s Documentation Fail? (2)

Documentation succeeds not through individual resolve, but through centralized knowledge, clear purpose, and systems that reduce the fear of being wrong. Interviews across a commerce domain and a server-development chapter show that documentation strategies must match an organization’s existing maturity, audience, and work patterns. AI lowers the cost of writing and sharing knowledge, while also requiring more deliberate document organization. ## Lessons from Early Attempts - The commerce wiki was initially designed as a self-service platform supported by workshops and guilds. - Workshops could encourage a first contribution, but sustaining second, third, and later contributions was difficult. - In the Ads domain, documentation was already strong, so the better approach was to respect existing conventions and help people locate knowledge rather than create another system. - Organizations with little documentation need to build foundational knowledge; organizations with mature documentation need better discovery and maintenance. ## Reducing the Fear of Asking and Writing - Developers often avoid asking questions because doing so publicly reveals what they do not know. - They may also hesitate to publish documentation because they fear their knowledge could be inaccurate. - The team addresses this through: - **“Lee’s Development Consultation Week,”** which normalizes questions and encourages teammates to answer questions Lee cannot address. - **A daily knowledge bot, “Ha,”** which shares short server-development tips automatically. - Correcting or adding to an existing shared post feels easier than writing a complete document from scratch. ## How AI Has Changed Documentation - AI makes it faster to create initial drafts and distribute knowledge through chatbots. - It also enables measurement of knowledge flow, including: - The number of questions asked. - Whether teammates provide answers. - The quality and content of those answers. - The number of new documents and week-over-week growth. - These metrics reveal knowledge gaps and recurring questions without manually reviewing every channel. - AI also creates a need for more detailed internal context than human readers typically require. - Commerce therefore separates: - Central, human-friendly documentation managed by technical writers. - Team-repository documentation containing detailed, team-specific context useful to AI but unnecessary for everyone else. ## Shared Principles and Organizational Differences - Both domains and chapters should centralize knowledge and avoid spreading it across too many channels. - Domains typically: - Connect documentation to products and code. - Change rapidly. - Serve a broad and varied audience. - Chapters typically: - Document conventions, working methods, and professional knowledge. - Change more slowly. - Focus on productivity and capability development. - Have a clearer audience, such as a specific role or discipline. - Domain documentation should be understandable even to non-developers, since developers may also lack context outside their specialties. - Separating guides, capability-based policies, glossaries, and metrics helps different readers find documents suited to their needs. ## Where to Begin - First diagnose the organization’s current documentation maturity by asking what people do when they get stuck: - **Ask coworkers or search chat:** foundational documentation is largely missing. - **Search documents:** assess whether information is easy to find; fill gaps if searches fail. - **Ask an AI or bot:** evaluate whether answers are accurate and whether the underlying documents are complete, current, centralized, and sufficiently contextualized. - Define the specific problem driving documentation, rather than starting with a vague goal. - Begin with a focused need, such as creating a glossary for inconsistent terminology or building references for sharing knowledge with other teams. The practical recommendation is to centralize knowledge, identify the organization’s biggest documentation gap, and build a low-friction system where people can contribute, correct, and consume information without relying solely on personal effort.

Read original(opens in new tab)
toss3 min readCurated summary

Why Does Our Team’s Documentation Fail? (1)

Documentation often fails not because people lack motivation, but because it depends on individual initiative and lacks clear standards. Interviews with a commerce domain and a server chapter showed that teams struggle to know what to document, how much detail to include, and whether their knowledge is accurate. Both organizations found that consolidating scattered knowledge into a shared system is the essential first step. ## Documentation in Domains and Chapters - **Domains** bring together developers, product owners, and designers around a business area such as commerce or advertising. - Their documentation focuses on product-related knowledge, including policies, terminology, and specifications. - **Chapters** group people with the same profession, such as server or frontend engineers. - Their documentation focuses on shared technical knowledge, conventions, and tools. - Dongjin works on consolidating internal knowledge across commerce and advertising domains, while Hyebin develops the company-wide documentation system “Todoc” and runs a documentation guild in the server chapter. ## Different Starting Points - The commerce domain already had strong awareness of documentation needs. - Members specifically requested terminology guides, policy documentation, experiment records, and API references. - Although writing standards were not clearly defined, people understood which documents would help their daily work. - The server chapter was initially more hesitant. - Members had worked without documentation and had not experienced its benefits directly. - An AI chatbot gave poor answers because its source documents were incomplete or disorganized. - Improving the underlying documents gradually made the chatbot more useful, helping members recognize the value of shared knowledge. ## Interviews Revealed the Real Obstacles - Dongjin interviewed developers to identify knowledge gaps and determine what information should be recorded. - The interviews clarified the organization’s needs, even though solving those needs required additional work. - Hyebin initially reviewed onboarding documents very thoroughly and repeatedly reminded people to complete them. - Interviews showed that contributors generally appreciated external review because it improved document quality. - The main problem was not a lack of motivation, but uncertainty: - What knowledge should be included? - How much detail is appropriate? - Is the information accurate enough to share? - These findings shifted the focus from persuading people to write toward making documentation easier and safer to produce. ## Problems Caused by Missing Documentation - In a domain, scattered policies create collaboration bottlenecks. - A team modifying a feature may first have to search for the policy owned by another team. - Newcomers struggle to understand what they do not know, creating prolonged “unknown unknowns.” - In a technical chapter, engineers often need to reconstruct the history behind unusual code. - They search old chat threads, try multiple keywords, or contact the original author. - More time may be spent assessing context and risk than implementing the change itself. - Useful knowledge often remains private. - Engineers may assume everyone already knows it or worry that it is too trivial to share. - As a result, people repeatedly solve the same problems independently, reducing overall productivity. ## Why Documentation Does Not Continue - Documentation benefits the future, while current work usually feels more urgent. - It is often treated as secondary work that requires a deliberate decision to begin. - Authors may also feel responsible for maintaining documents indefinitely. - Without documentation embedded in normal workflows, every update depends on personal willpower. - AI tools can reduce the effort of drafting and maintaining documents, but unclear standards and fear of being wrong remain significant barriers. Both organizations reached the same starting point: gather scattered knowledge in one accessible place, then integrate writing, review, and updates into everyday work rather than relying on individual motivation.

Read original(opens in new tab)
toss3 min readCurated summary

Creating a Role That Never Existed in the World

Technical Writing at Toss has evolved from producing documents to designing organizational knowledge systems. The core argument is that code captures outcomes but not the context, decisions, and history behind them—information that both employees and AI need. Toss’s Technical Writing Chapter therefore aims to make knowledge discoverable, structured, and increasingly self-sustaining, with the long-term goal of making the chapter unnecessary. ### Why Code Alone Is Not a Sufficient Source of Truth - Code records what a system does, but rarely explains: - Why it was designed that way - Which alternatives were considered - What organizational history shaped the decision - Employees often reconstruct context from colleagues’ memories or years-old messenger threads. - AI faces the same problem: it understands general knowledge but lacks an organization’s internal context. - A true Single Source of Truth requires both the code and the surrounding knowledge that explains it. ### From Writing Documents to Bringing Knowledge to People - Early work focused on creating onboarding documentation for the frontend chapter. - The team recognized that well-written documents are ineffective if people do not actively read or find them. - Toss created “Parkssi,” a chatbot integrated into messaging tools and IDEs: - Users ask questions conversationally. - Answers are based on existing documents. - Sources are provided for verification. - Instead of requiring employees to search for documents, the knowledge reaches them where they work. - Teams that previously ignored documentation began requesting similar systems to reduce repetitive questions and capture implicit knowledge. ### From Documents to Knowledge Systems - A knowledge system collects scattered information from code, conversations, deployments, and other sources. - It structures that information so both humans and AI can understand and use it through questions and automation. - Properly designed systems: - Increase productivity across the organization - Reduce communication costs as the company grows - Help employees adapt quickly and consistently - Toss defines knowledge as verified information that helps people understand situations, make better decisions, and act within a specific context. ### The Four Responsibilities of Toss’s Technical Writing Chapter - **Build products:** The chapter develops and operates “Todok,” an internal knowledge-management platform. - **Lead organizational documentation:** TWs work directly with teams to collect and organize knowledge according to each group’s needs. - **Automate Technical Writing:** AI workflows and automation help employees create and review documentation with consistent quality. - **Shape documentation culture:** The chapter runs company-wide sessions, documentation guilds, and knowledge committees focused on making knowledge easier for AI and people to use. ### A Broader Definition of the Technical Writer - Although the job title remains “Technical Writer,” the role now resembles a knowledge-infrastructure designer. - The role expanded by following organizational problems rather than staying within a fixed professional boundary. - The chapter’s ultimate goal is for teams to create and manage knowledge independently, eliminating the need for a dedicated TW chapter. - The series will explore Toss’s knowledge product, failed documentation approaches, automation of TW work, and the path toward self-sufficient organizations. Technical writers can create greater value by designing systems that make knowledge continuously available—not merely by writing more documents. As AI reshapes every profession, expanding a role around the problems it must solve is presented as an opportunity for any discipline.

Read original(opens in new tab)
lineOriginal article

Code Quality Improvement Techniques Part 2 (opens in new tab)

The quality of code documentation depends heavily on the hierarchy of information, specifically prioritizing high-level intent in the very first sentence. By focusing on abstract summaries rather than implementation details at the start, developers can ensure that readers understand a function's purpose instantly without parsing through sequential logic. This principle of "summary-first" communication enhances readability and developer productivity across documentation comments, inline explanations, and TODO tasks. ### Strategies for Effective Documentation * **Prioritize the first sentence:** Documentation comments should be written so that the overview is understandable from the first sentence alone. * **Increase abstraction levels:** Avoid simply repeating what the code does (e.g., "split by period and remove empty strings"). Instead, describe the result in domain terms, such as "returns a list of words grouped by sentences." * **Identify the most important element:** Since the primary goal of most functions is to produce a result, the summary should lead with what is being returned rather than how it is calculated. * **Layer the details:** Technical specifics—such as specific delimiters like `SENTENCE_SEPARATOR` ('.') or `WORD_SEPARATOR_REGEX` ([ ,]+)—and exclusion rules for empty strings should follow the initial summary. * **Use concrete examples:** For complex transformations or edge cases, include a sample input and output (e.g., showing how `" a bc. .d,,."` maps to `[["a", "bc"], ["d"]]`) to clarify boundary conditions. ### Prioritizing Intent in Non-Documentation Comments * **Focus on the "Why" for workarounds:** In inline comments, especially for "temporary fixes" or bug workarounds, the reason for the code's existence is more important than the action it performs. For instance, leading with "This is to avoid a bug in Device X" is more helpful than "Resetting the value to its previous state." * **Lead with the goal in TODOs:** When writing TODO comments, state the ideal state or the required change first. Explanations regarding current limitations or why the change cannot be made immediately should be relegated to the following sentences. * **Improve scannability:** Structuring comments this way allows developers to scan the codebase and understand the motivation behind complex logic without needing to read the entire comment block. To maintain a clean and maintainable codebase, always choose the most critical piece of information—whether it is the function's return value, a bug's context, or a future goal—and place it at the very beginning of your comments.

figma2 min readCurated summary

Design Systems: From the Basics to Big Things Ahead | Figma Blog

Design systems create consistency at scale while connecting design work to production. The post argues that as AI accelerates product development, organizations need a well-documented, shared foundation more than ever. It offers a progression from design-system fundamentals to adoption and measurement, alongside examples and resources for teams at different maturity levels. ## Design Systems 101 - Design systems evolved from: - Graphic-design and print-era style guides - Typographic standards and brand guidelines - Digital systems created by companies such as IBM, Microsoft, Apple, and Google - These systems translated visual and interaction standards from paper into digital interfaces. - The National Park Service’s adaptation of Massimo Vignelli’s 1977 design system illustrates how established systems can be carried into modern digital products. - Figma’s design-system series is intended for both teams starting their first system and organizations scaling existing ones. ## Documentation Drives Adoption - Documentation turns abstract principles into practical guidance for designers and developers. - It provides a shared reference point and helps users understand how to work with system tools and components. - Alaska Airlines prioritized documentation for its Auro design system, including guidance for Figma features such as auto layout and branch merging. - Documentation must serve different roles: - Some users need detailed specifications. - Others benefit from high-level explanations or visual examples. - As more roles participate in product design, documentation needs to remain clear, accessible, and relevant. ## Measuring Design-System ROI - Organizations can evaluate business impact through: - Component usage - Adoption rates - Consistency scores - Metrics can reveal not only whether a system is being used, but also where it needs improvement. - At athenahealth, increased detachments from a container component prompted investigation. - Detaching may indicate: - A component bug - Missing functionality - Unexpected combinations of existing elements - These signals help design-system teams prioritize fixes and enhancements. The practical recommendation is to treat a design system as an evolving product: establish strong foundations, document them for varied audiences, and use adoption and usage data to continually improve the system.

Read original(opens in new tab)