Code Comments and Developer Documentation

Code comments and developer documentation in industry-specific AI content strategies refer to structured annotations within source code and accompanying technical materials that explain the functionality, intent, and usage of AI systems tailored to sectors such as healthcare, finance, manufacturing, and autonomous vehicles. Their primary purpose is to enhance code maintainability, facilitate cross-functional collaboration, and enable AI-powered tools to automatically generate sector-specific content including API guides, compliance reports, and technical whitepapers ¹². This practice matters profoundly because it bridges human domain expertise with machine intelligence, reducing errors in AI model deployment by up to 40-50%, accelerating developer onboarding, and ensuring regulatory adherence through precise, context-aware documentation that scales with complex AI use cases like predictive analytics in pharmaceutical research or fraud detection in financial services ³⁵⁷.

Overview

The practice of code commenting emerged alongside early programming languages in the 1950s and 1960s, when developers recognized that code readability was essential for maintenance and collaboration. However, the integration of code comments and developer documentation into industry-specific AI content strategies represents a more recent evolution, driven by the convergence of three forces: the proliferation of complex machine learning systems requiring extensive explanation, the emergence of large language models (LLMs) capable of parsing and generating documentation, and the increasing regulatory scrutiny of AI systems in regulated industries ³⁷.

The fundamental challenge this practice addresses is the "documentation gap" in AI development—the disconnect between rapidly evolving AI codebases and the ability of teams to maintain current, accurate, and industry-compliant documentation. Traditional manual documentation approaches cannot keep pace with the velocity of AI model iterations, leading to outdated materials that hinder collaboration, increase onboarding time, and create compliance risks ¹⁵. In healthcare AI, for example, undocumented assumptions about data normalization can lead to model failures when deployed across different hospital systems with varying data standards.

The practice has evolved significantly over the past decade. Early AI documentation focused primarily on algorithm descriptions and mathematical formulations. Modern approaches treat code comments as structured inputs for AI-assisted content generation, where tools like GitHub Copilot, DocuWriter.ai, and IBM's AI documentation systems parse inline annotations to automatically produce living documentation that updates with code changes ²³⁷. This evolution reflects a shift from documentation as a post-development afterthought to documentation as an integral component of continuous integration/continuous deployment (CI/CD) pipelines, particularly critical in industries where AI systems must demonstrate auditability and explainability.

Key Concepts

Living Documentation

Living documentation refers to technical materials that automatically evolve alongside code changes through integration with version control systems and CI/CD pipelines ³. Unlike static documentation that becomes outdated, living documentation uses automated tools to extract information from code comments, docstrings, and metadata tags to regenerate current materials with each code commit.

Example: A pharmaceutical company developing an AI model for clinical trial patient matching implements living documentation using Sphinx integrated with their GitLab pipeline. When data scientists update the patient eligibility scoring algorithm and modify the associated Python docstrings to reflect new FDA guidance on diversity requirements, the CI/CD pipeline automatically regenerates the API reference documentation and compliance report within minutes of the merge, ensuring that clinical operations teams always reference current eligibility criteria ⁵.

Intent Articulation

Intent articulation involves documenting the reasoning behind algorithmic choices, architectural decisions, and implementation approaches rather than merely describing what the code does ⁴⁶. This concept is particularly critical in AI systems where multiple valid approaches exist, and the rationale for selecting specific techniques must be preserved for future maintainers and regulatory auditors.

Example: A financial services firm building a credit risk assessment model includes detailed intent comments explaining: "Uses XGBoost gradient boosting rather than deep neural networks because (1) model interpretability is required for FCRA adverse action notices, (2) training data contains only 50,000 samples insufficient for deep learning, and (3) XGBoost handles the 40% class imbalance in default cases more effectively per internal benchmarking." This articulation enables both AI documentation tools to generate compliant explanatory materials and future developers to understand constraints that shaped the design ²⁴.

Prompt Engineering for Documentation

Prompt engineering for documentation treats code comments as structured inputs that guide LLMs in generating industry-specific content ³⁴. This concept recognizes that AI assistants interpret comments as contextual prompts, making comment quality directly impact the relevance and accuracy of auto-generated documentation.

Example: An autonomous vehicle manufacturer structures comments in their perception system code using a standardized template: "SAFETY-CRITICAL: [function purpose] | ASSUMPTIONS: [environmental conditions] | FAILURE-MODES: [edge cases] | REGULATORY: [ISO 26262 reference]." When fed to their customized GPT-4 deployment, these structured comments generate safety case documentation that maps directly to automotive functional safety standards, reducing manual safety documentation effort by 60% while improving consistency ⁷.

Hierarchical Documentation Structure

Hierarchical documentation structure organizes comments and documentation across three levels: micro (inline comments explaining specific lines), meso (function/module-level docstrings describing interfaces and behavior), and macro (architecture documentation explaining system design) ⁵⁶. This layered approach ensures that different stakeholders—from individual developers to enterprise architects—can access appropriate detail levels.

Example: A healthcare AI platform for radiology image analysis implements this hierarchy: micro-level comments explain tensor transformation operations ("Normalize pixel values to [0,1] range per DICOM standard"), meso-level docstrings document the convolutional neural network layer APIs with parameter specifications, and macro-level architecture documents generated from aggregated comments explain the entire diagnostic pipeline from image ingestion through HIPAA-compliant result delivery, enabling radiologists, ML engineers, and compliance officers to each access relevant documentation ³⁵.

Metadata Tags for AI Parsing

Metadata tags are structured annotations using standardized formats like JSDoc's @param, @returns, @throws, or custom tags that enable AI tools to extract semantic information and generate structured outputs ²⁵. These tags transform unstructured comments into machine-readable data that can populate API specifications, generate type definitions, or create compliance matrices.

Example: A manufacturing AI system for predictive maintenance uses custom metadata tags in their Python codebase: @sensor-type: vibration, @failure-mode: bearing-degradation, @alert-threshold: 0.85, @industry-standard: ISO-13374. Their documentation automation pipeline parses these tags to automatically generate OpenAPI specifications for their REST API, populate a compliance matrix mapping code to ISO standards, and create sensor integration guides for field technicians—all from a single source of truth in the code comments ⁵⁷.

Documentation Debt

Documentation debt refers to the accumulated cost of outdated, incomplete, or misleading comments and documentation that impedes development velocity and increases maintenance burden ⁴⁶. Similar to technical debt, documentation debt compounds over time, eventually requiring significant remediation effort and creating risks when AI tools generate content based on incorrect information.

Example: A fintech startup's fraud detection system accumulated documentation debt when rapid feature development led to comments describing deprecated rule-based logic while the actual implementation had migrated to a neural network approach. When they integrated GitHub Copilot for code assistance, the tool generated suggestions based on the outdated comments, leading developers to implement incompatible features. The team invested two sprints conducting a documentation audit, updating 3,000+ comment blocks, and implementing pre-commit hooks that validate comment-code alignment, reducing future debt accumulation ¹⁴.

Domain-Specific Annotation Standards

Domain-specific annotation standards are industry-tailored commenting conventions that incorporate sector-specific terminology, regulatory references, and compliance requirements directly into code documentation ³⁷. These standards ensure that generated content aligns with industry expectations and regulatory frameworks.

Example: A consortium of healthcare AI developers establishes a shared annotation standard requiring all patient data processing functions to include tags for @phi-handling (describing protected health information treatment), @hipaa-safeguard (referencing applicable HIPAA security rules), and @audit-trail (explaining logging for compliance). When member organizations use this standard, their AI documentation tools generate consistent privacy impact assessments and security documentation that auditors can efficiently review across different healthcare AI products ²³.

Applications in Industry-Specific AI Development

Regulatory Compliance Documentation Generation

In highly regulated industries, code comments serve as the foundation for automatically generating compliance documentation required by regulatory bodies. Financial services firms use annotated AI code to produce model risk management documentation for Federal Reserve examinations, while medical device manufacturers generate FDA 510(k) submission materials from commented AI algorithms ³⁷.

A medical device company developing an AI-powered diagnostic algorithm for diabetic retinopathy embeds detailed comments referencing FDA guidance on software as a medical device (SaMD). Their documentation pipeline extracts these comments to automatically generate the Software Design Specification, Risk Analysis, and Verification and Validation protocols required for FDA submission. When the algorithm undergoes iterative improvements during clinical validation, updated comments trigger regeneration of submission documents, maintaining consistency between code and regulatory filings while reducing documentation preparation time from weeks to days ⁷.

Cross-Functional Knowledge Transfer

Code comments and developer documentation facilitate knowledge transfer between technical AI teams and non-technical stakeholders including product managers, domain experts, and business analysts. Industry-specific annotations enable AI tools to generate accessible explanations tailored to different audience expertise levels ²⁵.

An energy company building AI models for grid load forecasting uses structured comments that include both technical implementation details and business context. Their documentation system generates three parallel outputs from the same codebase: technical API documentation for data engineers, operational guides explaining forecast interpretation for grid operators, and executive summaries describing model capabilities for utility planning teams. When data scientists update the forecasting model to incorporate weather pattern recognition, all three documentation sets automatically update with appropriate detail levels, ensuring alignment across organizational functions ⁵.

AI Model Governance and Auditability

As organizations implement AI governance frameworks, code comments provide the audit trail necessary to demonstrate responsible AI practices. Comments documenting bias mitigation strategies, fairness testing, and ethical considerations enable automated generation of model cards, datasheets, and governance reports ³⁴.

A human resources technology company deploying AI for resume screening implements comprehensive governance annotations documenting their bias mitigation approach. Comments detail the demographic parity testing methodology, the synthetic data augmentation used to balance underrepresented groups, and the human-in-the-loop review thresholds. Their governance platform automatically aggregates these annotations to generate quarterly AI ethics reports for their board of directors, model cards published to candidates explaining the screening process, and audit logs demonstrating compliance with emerging AI fairness regulations ⁴.

Accelerated Developer Onboarding

Industry-specific AI projects often require developers to understand both complex technical implementations and domain-specific business logic. Well-commented code with AI-generated onboarding materials significantly reduces the time required for new team members to become productive contributors ¹⁵.

A logistics company with AI-powered route optimization brings on new machine learning engineers who lack supply chain domain expertise. Their codebase includes extensive comments explaining industry-specific concepts like "drayage operations," "detention fees," and "hours-of-service regulations" alongside the technical optimization algorithms. AI documentation tools generate interactive onboarding tutorials that combine code walkthroughs with domain concept explanations, reducing average onboarding time from six weeks to three weeks while improving new hire confidence in making code contributions ¹.

Best Practices

Prioritize "Why" Over "What" in Comments

The most valuable comments explain the reasoning behind implementation decisions rather than restating what the code obviously does ⁴⁶. This principle is especially critical in AI systems where multiple valid approaches exist and future maintainers need to understand the constraints and trade-offs that shaped current implementations.

Rationale: Self-documenting code with descriptive variable and function names already communicates what the code does. Comments should add information not readily apparent from reading the code itself, particularly the business context, algorithmic rationale, and industry-specific constraints that influenced design decisions ⁶.

Implementation Example: Instead of writing # Calculate the score above a complex calculation, a financial AI team writes: # Use exponential weighting (alpha=0.3) for recent transactions rather than simple average because fraud patterns shift rapidly; regulatory requirement to detect novel fraud within 24 hours per PCI-DSS 11.5 necessitates higher sensitivity to recent behavior changes. This comment enables AI documentation tools to generate meaningful explanations in compliance reports and helps future developers understand why alternative approaches were rejected ⁴⁶.

Integrate Documentation Validation into Code Review

Treating documentation quality as a mandatory code review criterion ensures that comments remain current and accurate as code evolves ¹³. Automated validation tools can enforce documentation standards before code merges.

Rationale: Documentation drift occurs when code changes but comments don't update accordingly. Making documentation review a blocking requirement in the development workflow prevents accumulation of documentation debt and ensures AI-generated content remains accurate ¹.

Implementation Example: A pharmaceutical AI research team implements pre-commit hooks that validate docstring completeness, check that comments reference current API versions, and flag functions lacking industry-specific annotations (like @gxp-impact for GxP-regulated processes). Their code review checklist includes a mandatory item: "Documentation accurately reflects code behavior and includes rationale for algorithmic choices." Pull requests failing documentation validation cannot merge, maintaining documentation quality across their 200+ model repository ¹³.

Structure Comments as AI-Readable Prompts

Recognizing that AI assistants interpret comments as contextual information, developers should structure comments using consistent formats, clear language, and explicit domain terminology that guides AI tools toward generating accurate, industry-appropriate content ³⁴.

Rationale: LLMs powering documentation tools perform better with structured, explicit input. Ambiguous or inconsistent comments lead to generic or incorrect AI-generated documentation, while well-structured comments enable high-quality automated content generation ⁴.

Implementation Example: An autonomous vehicle company establishes a comment template for safety-critical functions: [SAFETY-LEVEL: ASIL-D] [PURPOSE: brief description] [ASSUMPTIONS: environmental/input assumptions] [FAILURE-HANDLING: degradation strategy] [TEST-COVERAGE: reference to safety test cases]. This structure enables their AI documentation pipeline to automatically generate safety case arguments, map code to ISO 26262 requirements, and produce technical safety reports that directly support certification activities. The consistent format also improves GitHub Copilot's ability to suggest contextually appropriate code completions ³⁷.

Implement Continuous Documentation Regeneration

Rather than treating documentation as a periodic manual task, integrate automated documentation generation into CI/CD pipelines so that documentation updates automatically with every code change ¹⁵.

Rationale: Manual documentation updates lag behind code changes, creating windows where documentation is inaccurate. Automated regeneration ensures documentation currency and reduces the cognitive burden on developers to manually maintain multiple documentation artifacts ⁵.

Implementation Example: A manufacturing AI platform implements a documentation pipeline where every merge to their main branch triggers: (1) Sphinx regeneration of API documentation from Python docstrings, (2) Mermaid diagram generation from architectural comments, (3) OpenAPI specification updates from endpoint annotations, and (4) compliance matrix updates mapping code comments to industry standards. The entire process completes in under five minutes, and updated documentation automatically deploys to their internal developer portal. This approach reduced documentation staleness incidents from 15+ per quarter to zero while eliminating the previous practice of quarterly "documentation sprints" ¹⁵.

Implementation Considerations

Tool and Format Selection

Choosing appropriate documentation tools and formats depends on the programming languages used, the target audience, and the specific industry requirements. Python-heavy AI projects typically leverage Sphinx or MkDocs, while polyglot environments may require language-agnostic solutions like Doxygen ⁵⁷.

Organizations should evaluate tools based on their AI integration capabilities. DocuWriter.ai and similar platforms offer native LLM integration for enhanced content generation, while traditional tools like JSDoc or Pydoc may require custom scripting to incorporate AI assistance ¹². For regulated industries, tools must support traceability features linking generated documentation back to specific code versions and comments.

A healthcare AI company standardizes on Sphinx with custom extensions that parse their domain-specific tags (@phi-handling, @hipaa-safeguard) and integrate with their GPT-4 deployment to generate patient-friendly explanations of AI decision-making. They selected Sphinx because it supports their Python-heavy codebase, integrates with their GitLab CI/CD pipeline, and allows custom rendering templates that match their corporate documentation standards and regulatory submission formats ⁵⁷.

Audience-Specific Customization

Effective documentation strategies generate multiple documentation artifacts from a single commented codebase, each tailored to specific audience needs and expertise levels ²⁵. Technical audiences require API references and implementation details, while business stakeholders need high-level capability descriptions and compliance summaries.

AI documentation tools can transform the same source comments into varied outputs by applying different generation prompts and templates. A financial services firm generates three documentation sets from their fraud detection codebase: detailed technical documentation for ML engineers, operational runbooks for fraud analysts explaining model outputs and override procedures, and executive dashboards summarizing model performance metrics and regulatory compliance status. Each audience receives appropriate information depth without requiring separate documentation maintenance efforts ².

Organizational Maturity and Context

Documentation strategies must align with organizational maturity in both software development practices and AI adoption. Organizations with mature DevOps practices can implement sophisticated automated documentation pipelines, while those earlier in their journey may need to establish foundational practices first ¹³.

Startups and small teams might begin with basic inline commenting standards and simple README files before investing in complex automation. As codebases grow and teams expand, they can progressively adopt automated generation tools, living documentation frameworks, and AI-assisted content creation ¹.

A mid-sized insurance company progressed through three maturity stages: (1) establishing basic commenting standards and manual documentation in year one, (2) implementing automated API documentation generation from docstrings in year two, and (3) deploying AI-assisted documentation with custom LLM integration in year three. This phased approach allowed their team to build documentation discipline before introducing automation complexity, resulting in higher adoption rates than peer organizations that attempted immediate full automation ³.

Integration with Existing Development Workflows

Successful implementation requires seamless integration with existing development tools and workflows rather than imposing separate documentation processes ¹⁵. Documentation practices should enhance rather than impede development velocity.

Integration points include IDE plugins that provide real-time documentation feedback, pre-commit hooks that validate comment quality, code review checklists that include documentation criteria, and CI/CD pipeline stages that generate and deploy documentation ¹. A manufacturing AI team integrated documentation validation into their existing Jira workflow, automatically creating documentation review tasks when pull requests modify public APIs, and blocking sprint completion until documentation updates are verified. This integration leveraged existing project management habits rather than requiring new tools or processes ⁵.

Common Challenges and Solutions

Challenge: Documentation Drift and Staleness

Documentation drift occurs when code evolves but comments and external documentation fail to update accordingly, creating dangerous misalignment between documented behavior and actual implementation ¹⁴. This challenge intensifies in fast-moving AI projects where models undergo frequent retraining and algorithm updates. Stale documentation misleads developers, causes integration errors, and creates compliance risks when regulatory submissions describe outdated system behavior.

Solution:

Implement automated documentation validation as a mandatory gate in the development pipeline. Pre-commit hooks can detect functions modified without corresponding docstring updates, while CI/CD stages can compare generated documentation against previous versions to flag significant undocumented changes ¹³. A pharmaceutical AI team deployed a custom linting tool that parses git diffs to identify modified functions and verifies that associated comments have recent update timestamps. Pull requests failing this check cannot merge until developers either update documentation or explicitly mark comments as still-accurate. This approach reduced documentation drift incidents by 85% within six months ¹.

Additionally, schedule regular documentation audits as part of sprint planning. Allocate 10-15% of development capacity to documentation maintenance, treating it as technical debt reduction rather than optional overhead ⁴. Organizations can gamify this process by tracking documentation coverage metrics and celebrating teams that maintain high documentation quality scores.

Challenge: Balancing Detail with Conciseness

Developers struggle to determine appropriate comment detail levels—too sparse and comments lack useful context, too verbose and they create maintenance burden while obscuring code readability ⁶⁸. In industry-specific AI, this challenge intensifies because domain context requires explanation, but excessive detail makes code difficult to navigate. Over-commenting can be as problematic as under-commenting, particularly when AI tools generate verbose outputs from overly detailed inputs.

Solution:

Establish clear commenting guidelines that specify when and what to document based on code complexity and audience needs ⁶⁸. A practical framework: (1) omit comments for self-evident code with descriptive naming, (2) use brief inline comments for non-obvious logic, (3) provide comprehensive docstrings for public APIs and complex algorithms, and (4) create separate architecture documents for system-level design rather than embedding extensive explanations in code ⁶.

An energy sector AI team implemented a "comment budget" guideline: inline comments should not exceed 20% of code lines in a function, and individual comments should stay under three lines. For complex algorithms requiring extensive explanation, they create separate Markdown documentation files linked from brief code comments: # Implements adaptive learning rate scheduling; see docs/training/learning-rate-strategy.md for rationale and benchmarking results. This approach keeps code readable while preserving detailed context in accessible locations ⁸.

Challenge: AI Misinterpretation of Ambiguous Comments

AI documentation tools can generate incorrect or misleading content when source comments use ambiguous language, inconsistent terminology, or lack necessary context ⁴. This challenge is particularly acute in industry-specific AI where domain terminology may have multiple interpretations. Ambiguous comments like "handles edge cases" or "optimizes performance" provide insufficient information for AI tools to generate meaningful documentation.

Solution:

Develop domain-specific commenting standards that define required terminology, specify explicit formats for common documentation patterns, and provide examples of high-quality comments ³⁴. Create a "documentation style guide" similar to code style guides, with approved terminology for industry concepts and templates for documenting common AI patterns like model training, inference pipelines, and data preprocessing.

A financial services organization created a commenting lexicon defining precise terms for their fraud detection domain: "transaction velocity" specifically means "count of transactions per account per hour," while "anomaly threshold" requires specification of the statistical method (e.g., "3-sigma threshold on z-scored transaction amounts"). They integrated this lexicon into their IDE as autocomplete suggestions and configured their AI documentation tools with custom prompts that reference the lexicon, ensuring consistent interpretation. This reduced AI-generated documentation errors by 70% ⁴.

Additionally, implement human review of AI-generated documentation before publication. Treat AI tools as draft generators rather than final authorities, with subject matter experts validating technical accuracy and domain appropriateness ²⁷.

Challenge: Maintaining Documentation Across Distributed Teams

Organizations with distributed AI development teams across multiple time zones and geographic locations struggle to maintain consistent documentation practices and standards ¹. Different teams may adopt incompatible commenting styles, use different tools, or have varying documentation quality expectations, leading to fragmented documentation that impedes collaboration and knowledge sharing.

Solution:

Establish centralized documentation governance with clear ownership, standardized tooling, and automated enforcement of documentation standards across all teams ¹³. Designate documentation champions within each team responsible for maintaining quality and consistency, and create a cross-team documentation working group that establishes standards, evaluates tools, and shares best practices.

A global manufacturing AI company with teams in Germany, India, and the United States implemented a unified documentation platform based on MkDocs with custom plugins enforcing their corporate commenting standards. All teams use the same IDE configuration with shared linting rules, the same CI/CD pipeline templates that include documentation validation, and the same AI documentation tools configured with company-wide prompts. They conduct monthly documentation reviews where teams present their documentation approaches and share lessons learned, fostering continuous improvement and cross-pollination of effective practices ³.

Leverage asynchronous documentation review processes that accommodate time zone differences. Use pull request comments for documentation feedback rather than requiring synchronous meetings, and maintain a shared documentation knowledge base where teams can reference examples of high-quality comments and generated documentation ¹.

Challenge: Balancing Automation with Human Expertise

While AI-powered documentation tools offer significant efficiency gains, over-reliance on automation can produce generic, technically accurate but contextually inappropriate documentation that lacks the nuanced understanding human experts provide ²⁷. Conversely, rejecting automation entirely wastes opportunities for efficiency and consistency. Finding the optimal balance between AI assistance and human expertise remains challenging.

Solution:

Implement a "human-in-the-loop" documentation workflow where AI tools generate initial drafts that human experts review, refine, and approve before publication ²⁷. This approach leverages AI efficiency for routine documentation tasks while preserving human judgment for complex explanations, industry-specific context, and quality assurance.

A healthcare AI organization uses a tiered approach: AI tools automatically generate and publish API reference documentation from well-structured docstrings without human review (since these are factual descriptions of interfaces), but AI-generated conceptual documentation, architecture guides, and compliance reports require review by senior engineers or domain experts before publication. They track metrics on AI-generated content quality, gradually expanding the scope of auto-published documentation as AI accuracy improves ².

Invest in customizing AI documentation tools with industry-specific training or prompts rather than using generic configurations. A financial services firm fine-tuned their documentation LLM on a corpus of approved regulatory documentation, internal architecture decision records, and high-quality code comments from their senior engineers. This customization improved the relevance and accuracy of AI-generated content, reducing the human review burden while maintaining quality standards ⁷.

References

1. DocuWriter.ai. (2024). Code Commenting Best Practices for Modern Development Teams. https://www.docuwriter.ai/posts/code-commenting-best-practices-modern-development-teams
2. Pluralsight. (2024). Documenting and Commenting Code with AI. https://www.pluralsight.com/resources/blog/software-development/documenting-commenting-code-with-AI
3. Kinde. (2024). Building AI-Enhanced Documentation: From Code Comments to Living Architecture Docs. https://kinde.com/learn/ai-for-software-engineering/best-practice/building-ai-enhanced-documentation-from-code-comments-to-living-architecture-docs/
4. Glean. (2024). How AI Assistants Interpret Code Comments: A Practical Guide. https://www.glean.com/perspectives/how-ai-assistants-interpret-code-comments-a-practical-guide
5. Graphite. (2024). AI Code Documentation Automation. https://graphite.com/guides/ai-code-documentation-automation
6. Dev.to. (2024). How to Write Professional Code Comments: A Beginner's Guide to Better Code Documentation. https://dev.to/anurag_dev/how-to-write-professional-code-comments-a-beginners-guide-to-better-code-documentation-27hf
7. IBM. (2024). AI Code Documentation: Benefits and Top Tips. https://www.ibm.com/think/insights/ai-code-documentation-benefits-top-tips
8. I'd Rather Be Writing. (2014). Tips for Writing Code Comments in Developer Documentation. https://idratherbewriting.com/2014/01/11/tips-for-writing-code-comments-in-developer-documentation/