diff --git a/white-paper/benefits.qmd b/white-paper/benefits.qmd
index 3a610f7..91814c2 100644
--- a/white-paper/benefits.qmd
+++ b/white-paper/benefits.qmd
@@ -2,4 +2,103 @@
 
 ## Introduction
 
-This chapter aims to include at a high level some benefits for using Git in clinical development.
\ No newline at end of file
+Git is much more than a version control system. In clinical development, it can improve quality, reproducibility, and efficiency across the entire development lifecycle. By providing a transparent history of code changes, facilitating collaboration among programmers, and supporting modern automation practices, Git helps teams work more effectively while maintaining traceability and compliance. In addition, Git serves as the foundation for advanced capabilities such as continuous integration and deployment (CI/CD) pipelines and AI-assisted development tools, enabling faster and more reliable delivery of statistical programming solutions.
+
+```{mermaid}
+%%| label: fig-git-benefits
+%%| fig-cap: "Overview of Git benefits"
+%%{init: {"themeVariables": {"fontSize": "50px"}}}%%
+
+flowchart TD
+    git["Git"]
+
+    trace["Traceability"]
+    collab["Collaboration"]
+    auto["Automation"]
+
+    audit["Audit trail"]
+    review["Change review"]
+    compliance["Compliance"]
+
+    share["Easier sharing"]
+    repro["Reproducibility"]
+    knowledge["Knowledge retention"]
+
+    cicd["CI/CD"]
+    security["Security scanning"]
+    ai["AI-assisted coding"]
+
+    git --> trace
+    git --> collab
+    git --> auto
+
+    trace --> audit
+    trace --> review
+    trace --> compliance
+
+    collab --> share
+    collab --> repro
+    collab --> knowledge
+
+    auto --> cicd
+    auto --> security
+    auto --> ai
+```
+
+## Traceability
+
+Git provides a complete and transparent record of how code evolves over time. Every change is associated with an author, timestamp, and description, creating a detailed history that can be reviewed, understood, and revisited whenever needed. This improves accountability, facilitates troubleshooting, and helps teams understand the development path that led to a particular result. As a result, teams can work more confidently, knowing that previous decisions and implementations remain accessible and verifiable.
+
+### Audit Trail
+
+Git automatically preserves a history of all committed changes, allowing teams to determine who introduced a change, when it was made, and often why it was made, without relying on manually maintained documentation. This built-in audit trail remains linked directly to the relevant source code, provides greater transparency than traditional shared-drive approaches, and supports quality-focused ways of working. Investigations can be simplified when questions arise during validation, peer review, or inspections, as historical changes can be examined quickly and objectively.
+
+### Change Review
+
+Git enables structured review of modifications before they become part of the main codebase. Reviewers can focus exclusively on comparing differences in lines between versions, making reviews more efficient and effective. This targeted approach promotes knowledge sharing, encourages adherence to programming standards, and improves code quality by identifying issues earlier in the development lifecycle. Over time, routine review practices can contribute to more consistent and maintainable codebases.
+
+### Compliance
+
+Although Git is not a compliance solution on its own, it provides capabilities that support compliance-related activities. Version histories, documented reviews, and controlled change tracking help demonstrate how analyses were developed and maintained. By making development activities more transparent and reproducible, Git helps organizations establish processes that are easier to govern, monitor, and defend during audits or inspections.
+
+## Collaboration
+
+Git allows multiple programmers to work on the same project while maintaining a shared and consistent source of truth. By centralizing code and its history, Git reduces reliance on individual file copies, email exchanges, and manually coordinated updates. This supports more efficient teamwork and improves the long-term sustainability of programming assets.
+
+### Easier Sharing
+
+Code, documentation, and supporting materials can be accessed through a common repository rather than being distributed across personal folders, network drives, or email chains. This reduces duplicate work, minimizes confusion around file ownership, and allows team members to quickly understand what already exists before creating new solutions. Increased visibility also encourages reuse of proven approaches, helping teams work more efficiently and consistently.
+
+Git repositories can also serve as centralized locations for reusable utilities, templates, and packages, making it easier to share proven solutions across projects and reducing duplication of effort. By providing a common location for programming assets, Git promotes standardization and enables successful approaches developed in one project to be leveraged by others.
+
+### Reproducibility
+
+A repository preserves the exact versions of code used at any point in time. This makes it possible to recreate historical analyses, understand how results were generated, and recover prior states of a project when needed. Consistent access to versioned code strengthens confidence in analytical results, supports validation activities, and reduces the risk that important analyses cannot be reproduced in the future.
+
+### Knowledge Retention
+
+Projects often span many years, involve multiple contributors, and may outlive the tenure or availability of individual team members. Git captures not only the latest code but also its development history. This institutional knowledge remains available even when team members change roles, leave projects, or move to other organizations. By reducing reliance on individual expertise, Git helps teams maintain continuity and sustain quality over the long term.
+
+## Automation
+
+Git serves as the foundation for a growing ecosystem of tools that automate repetitive tasks and improve development workflows. By connecting code changes to automated processes, teams can spend less time on manual activities and more time on analysis and problem solving. Automation also helps ensure that routine checks are performed consistently every time code changes.
+
+### CI/CD
+
+When code changes are committed, Continuous Integration and Continuous Delivery (CI/CD) pipelines can automatically execute predefined workflows, such as running validation checks, executing tests, generating reports, or deploying applications. Automation reduces manual effort, promotes consistency, and helps identify issues sooner. By providing rapid feedback on code changes, CI/CD practices can improve both development efficiency and overall quality.
+
+### Security Scanning
+
+Modern Git platforms can automatically evaluate repositories for security vulnerabilities, outdated dependencies, or policy violations. Automated checks can identify potential concerns before code is released or shared, helping teams address issues earlier and with less manual effort.
+
+### AI-Assisted Coding
+
+AI-based development tools increasingly integrate directly with Git repositories and development workflows. Git provides the traceability needed to review, validate, and approve AI-generated changes using the same processes applied to human-written code. This allows teams to realize productivity gains while maintaining appropriate oversight, preserving quality standards, and ensuring that generated code remains subject to the same review and governance expectations as any other contribution.
+
+This is particularly valuable when AI tools perform similar updates across many programs, such as implementing changes required by updates to standards, utilities, or common programming patterns. Git's comparison and review capabilities allow programmers to quickly identify what was modified, assess the impact of those changes, and gain confidence in the resulting implementation before it is incorporated into production code. Organizations may also choose to identify AI-assisted contributions through pull request conventions, labels, or other repository governance practices, making it easier to apply appropriate levels of review and oversight.
+
+## Summary
+
+Git does not improve quality through a single feature. Rather, quality emerges from the combination of traceability, collaboration, and automation. Together, these capabilities improve transparency, reproducibility, consistency, and efficiency, helping teams deliver high-quality analytical solutions while maintaining confidence in their development processes.
+
+