Enriching Code Context with Git Diffs for Smarter Developer Tools

Ever wished your IDE could “remember” your recent changes and use them to help you code smarter, not harder? As developers, we’re constantly juggling context—what we changed, why we changed it, and how it fits into the larger codebase. In fast-paced or large projects, this context often slips through the cracks, leading to inefficiencies, bugs, or missed opportunities for optimisation.

Think about it: How many times have you forgotten the reasoning behind a recent change, only to revisit it later with a blank slate? Traditional tools treat code as static, ignoring the dynamic nature of development. But what if we could enrich our tools with Git diff context, making them more intuitive and proactive? Let’s explore how leveraging Git diffs can transform the way we code.

---

I. The Challenge: Bridging the Gap Between Code and Context

The Problem: Static Tools in a Dynamic World

I encountered this problem while building Codedraft, an opensource VSCode extension that helps software engineers turn their coding learnings into blog drafts, helping them maintain a consistent technical writing habit.

Most developer tools treat code as a snapshot in time. They lack awareness of how the code evolved or why certain changes were made. This disconnect leads to tools that feel out of touch with the developer’s workflow. For example, consider a tool that suggests refactorings without knowing what you’ve recently changed—it might propose changes you’ve already implemented or miss opportunities to align with your current work.

The Technical Trade-off: Metadata vs. Diffs

Initially, I thought Git metadata would solve this problem. After all, Git provides commit hashes, messages, and timestamps. But here’s the catch: metadata only tells you that something changed, not what changed.

const commit = await repo.getCommit(hash); // Returns metadata, not the diff

This approach falls short because it lacks granularity. To build smarter tools, we need to understand the actual changes—the diffs—not just the high-level metadata.

---

II. The Solution: Leveraging Git Diffs for Richer Context

Approach: Fetching Diffs Directly

The key to bridging this gap is to fetch Git diffs directly. Diffs provide a detailed view of what changed, line by line, making them a goldmine for context-aware tools. To achieve this, I wrote a helper function that runs Git commands via subprocesses.

private runGitCommand(args: string[], cwd: string): Promise<string> {
    return new Promise((resolve, reject) => {
        const { exec } = require('child_process');
        const command = `git ${args.join(' ')}`;

        exec(command, { cwd }, (error: any, stdout: string) => {
            if (error) {
                reject(error);
                return;
            }
            resolve(stdout);
        });
    });
}

This function allows us to execute Git commands programmatically, retrieving diffs for specific commits or ranges.

Application: Integrating Diffs into Developer Tools

With diffs in hand, we can enrich tools in countless ways. For example, consider a tool that generates learning notes from code changes. By including the diff context, the notes become more meaningful and actionable.

private formatCaptureForPrompt(capture: CaptureItem): string {
    let text = `### ${capture.notes || 'Learning Point'}\n\n`;

    if (capture.code) {
        text += `**File:** \`${capture.code.filePath}\`\n`;
        if (capture.context?.functionName) {
            text += `**Function:** \`${capture.context.functionName}\`\n`;
        }
        text += `\n\`\`\`${capture.code.language}\n${capture.code.snippet}\n\`\`\`\n\n`;
    }

    text += `**My notes:** ${capture.notes}\n`;

    if (capture.context?.diff) {
        text += `\n**Git Diff Context:**\n\`\`\`diff\n${capture.context.diff.substring(0, 1000)}${capture.context.diff.length > 1000 ? '\n... [diff truncated]' : ''}\n\`\`\`\n`;
    }

    return text;
}

Here, the diff is included as part of the context, providing a clear picture of what changed and why.

---

III. Real-World Impact: Smarter Tools, Happier Developers

Example Use Case: Context-Aware Code Reviews

Imagine a code review tool that highlights not just the changes but also the context behind them. By integrating diffs, reviewers can see the evolution of the code, making it easier to understand the intent behind changes.

async getCommitDiff(hash: string): Promise<string | null> {
    const repo = this.getRepository();
    if (!repo) return null;

    try {
        return await this.runGitCommand(['show', hash], repo.rootUri.fsPath);
    } catch (error) {
        console.error(`Git error (commit diff ${hash}):`, error);
    }
    return null;
}

This function fetches the diff for a specific commit, enabling tools to display granular changes alongside code reviews.

Beyond Code Reviews: Proactive Suggestions

Diffs can also power proactive suggestions. For instance, a tool could detect patterns in recent changes and suggest refactorings or optimisations. By understanding the context of changes, these suggestions become more relevant and less intrusive.

---

IV. Key Insights and Takeaways

1. Metadata Isn’t Enough: While Git metadata is useful, it lacks the granularity needed for context-aware tools. Diffs provide the missing piece.
2. Subprocesses Are Your Friend: Running Git commands via subprocesses is a straightforward way to fetch diffs programmatically.
3. Context Is King: Enriching tools with diff context makes them more intuitive and aligned with the developer’s workflow.

By leveraging Git diffs, we can build smarter, more proactive tools that feel like an extension of the developer’s mind. Whether it’s code reviews, learning tools, or refactoring suggestions, diff context bridges the gap between static code and dynamic development.

So, the next time you’re building a developer tool, ask yourself: How can I use diffs to make this tool more context-aware? Your users—and your future self—will thank you.