November 2025 Summaries
101 posts from Graphite
Filter
Month:
Year:
Post Summaries
Back to Blog
Graphite's redesign of its Pull Request (PR) page aimed to create a more intuitive and visually clear experience for users, addressing the cluttered interface that previously overwhelmed them. Drawing inspiration from GitHub while maintaining a unique identity, the overhaul focused on reducing visual noise and incorporating new features like floating comments and a rich text editor to enhance accessibility and participation. Floating comments were introduced to maintain reviewers' focus by allowing comments to hover contextually beside relevant code, while the rich text editor catered to non-technical collaborators unfamiliar with markdown syntax. The redesign process involved experimenting with different layouts for the stack of PRs, ultimately retaining the original horizontal layout for better readability and usability. The iterative design approach, which included internal testing and refinement, ensured a smoother and more cohesive user experience, reinforcing Graphite’s commitment to making code reviews faster and more efficient.
Nov 30, 2025
1,016 words in the original blog post.
The newly redesigned PR page aims to enhance the efficiency and clarity of code reviews by incorporating several key features that align with developers' workflows. Essential details such as PR status, checks, reviewers, and metadata are prominently displayed at the top for quick access, while a reorganized navigation system places the file tree to the left and versions above the diff, allowing for seamless navigation and iteration tracking. The addition of a rich text editor enables more dynamic PR descriptions and comments, while Action Cards provide real-time updates and allow authors to resolve conflicts instantly. A cleaner diff view and the ability to start reviews from any point on the page streamline the review process, and a consolidated panel for CI summaries and job details eliminates the need for extensive navigation through the UI. Overall, the redesign reduces visual clutter and focuses on making reviews faster and more intuitive.
Nov 22, 2025
355 words in the original blog post.
Graphite has expanded its capabilities to allow developers to collaborate on stacked pull requests (PRs) in real-time, addressing the challenges of managing collaborative stacks with multiple authors that traditional Git struggles to handle. With the introduction of this feature, which has been refined through user feedback since version 0.19 of the Graphite CLI, developers can now easily fetch, create, and submit shared stacks using familiar commands like gt get, gt create, and gt submit. This enhancement enables teams to work simultaneously on different parts of a feature without blocking each other's progress, effectively dividing tasks such as data model changes, backend logic, API endpoint addition, and frontend development among team members. Graphite's underlying system automates the resolution of complex Git states, ensuring a seamless collaborative experience by automatically rebasing local changes when necessary. With the release of Graphite CLI version 1.3.4+, teams can fully utilize shared stacks, empowering them with advanced Git functionalities to streamline their workflow.
Nov 09, 2025
528 words in the original blog post.
Developers often face the challenge of dealing with blocked pull requests (PRs) due to dependencies, such as needing to build a feature on top of another unmerged one, which can impact meeting deadlines and workflow efficiency. Traditional options include waiting for PR approval, interrupting teammates for faster reviews, or merging dependent changes into a single large PR, which can complicate reviews and increase bug risk. A potential solution is stacking PRs, where one PR is built on top of another, allowing developers to continue work without creating excessively large PRs. However, this requires code review tools that can handle stacked changes, a feature commonly supported by platforms at companies like Facebook and Google but not yet widespread in public tools. Graphite is introduced as a new platform designed to fill this gap by enabling stacked changes on top of Git and integrating with GitHub, allowing developers to maintain their current workflows while benefiting from easier and faster code reviews. Currently in closed beta, Graphite aims to streamline the code review process for developers across various organizations.
Nov 09, 2025
618 words in the original blog post.
The text discusses the challenges developers face with traditional GitHub pull request (PR) workflows, highlighting how large and complex PRs can slow down review cycles, introduce bugs, and create bottlenecks in the development process. It introduces "stacking" as a solution, a method that breaks down large features into small, manageable, and interdependent PRs that streamline the review process, enhance code quality, and increase development speed. By using tools like Graphite, which automates the stacking workflow, developers can maintain continuous integration with the main branch, reduce technical debt, and minimize downtime caused by monolithic changes. Stacking facilitates a more efficient and productive development environment by enabling parallelized development and review, resulting in more reliable and timely project delivery.
Nov 09, 2025
2,532 words in the original blog post.
Graphite is enhancing its code review process on GitHub with new features designed to simplify working with stacked changes, which can be cumbersome and prone to errors without proper tooling. The launch includes four key features: Stack Edit, which introduces a robust interface for creating and editing stacks of pull requests (PRs) with shared labels, reviewers, and settings; Stack Visualization, which provides a clear view of the broader context of any PR within a stack; an interactive terminal tutorial called "gt demo" for learning how to use Graphite effectively; and AI-generated stack titles that offer reviewers a concise understanding of a stack's overall purpose. These innovations aim to streamline and automate the review process, making it more efficient and accessible, with some features currently available in private beta.
Nov 09, 2025
720 words in the original blog post.
Graphite has transitioned its web domain from graphite.dev to graphite.com, enhancing its platform while maintaining its core functionalities. Users will need to sign in again upon their first visit to the new domain, and Slack integrations may require updating the Graphite Slack app’s permissions by re-installing it. For GitHub Cloud users, replacing github.com with graphite.com in any pull request URL will open it in Graphite. This domain change signifies Graphite's growth from a developer tool to a comprehensive AI-powered code review platform designed to accelerate engineering workflows. Users experiencing login issues or with questions are encouraged to contact [email protected].
Nov 09, 2025
175 words in the original blog post.
Graphite Interactive, a graphical user interface now available in pre-release on the VSCode marketplace, enables users to manage changes without using the command line, inspired by Facebook's Interactive Smartlog. Users are encouraged to join the Slack community for feedback and questions. The Graphite Team plan offers exclusive access to the Graphite Merge Queue, with a new feature allowing PRs to be added via labeling, which is beneficial for team members not using Graphite. Additionally, the update includes minor fixes, product tour videos, and improvements in CLI collaboration, such as automatic incorporation of non-conflicting remote changes and a new flag to re-request reviews on PRs.
Nov 09, 2025
215 words in the original blog post.
Graphite's recent launch of its AI code review features prompted a comprehensive redesign of its landing page, which was brought in-house to ensure the brand's vision was accurately reflected and to maintain flexibility for rapid iteration. The redesign process was led by CEO Merrill Lutsky, who emphasized creating a striking and memorable experience that communicates the company's dedication to detail from the outset. The design journey involved exploring various themes, ultimately settling on a neon lighting concept inspired by artist Ivan Navarro, which was applied to elements like the hero section and footer with interactive and dynamic visual effects. The technical execution required overcoming challenges related to performance across devices, utilizing tools like Blender, Next.js, and BrowserStack to achieve a balance between high fidelity and accessibility. By treating the landing page as an evolving product, the team was able to continually refine and adapt the design post-launch, with leadership support allowing for the necessary time and resources to achieve a product they are proud to present.
Nov 09, 2025
1,380 words in the original blog post.
Stack Overflow emerged in 2008 as a free, community-driven Q&A platform for developers, countering paid models like Experts Exchange, which had frustrated users by charging for access to user-generated content. Conceived by bloggers Joel Spolsky and Jeff Atwood, Stack Overflow was designed to democratize access to programming knowledge by allowing questions and answers to be freely shared and indexed by search engines, fostering a collaborative environment akin to open-source software. Over the years, Stack Overflow diversified its revenue streams beyond traditional advertising, introducing services like Stack Overflow Careers and enterprise solutions. However, the platform now faces challenges from AI tools such as ChatGPT, which offer rapid, personalized responses and could potentially disrupt the community-based model by reducing engagement and the quality of peer-reviewed content. As AI continues to evolve, Stack Overflow's future hinges on its ability to adapt while maintaining its core mission of open access and community-driven knowledge sharing.
Nov 09, 2025
3,171 words in the original blog post.
Graphite has introduced three new features aimed at enhancing the code review process to make it faster, more efficient, and scalable. The first feature, Automations, allows developers to implement if-this-then-that style rules to automate tasks like adding reviewers, labels, and comments on pull requests, thereby reducing manual efforts. The second feature is the Graphite menu bar app, which provides a centralized inbox for managing pull request notifications directly from the desktop, allowing developers to filter and focus on relevant updates without constant interruptions. Lastly, Graphite's AI code suggestions enable reviewers to convert comments into actionable code suggestions with a single click, streamlining the feedback process and helping authors implement changes more quickly. These features are designed to minimize administrative tasks, enhance productivity, and allow developers to focus on building high-quality products.
Nov 09, 2025
815 words in the original blog post.
Pull requests are vital to modern software development workflows, facilitating code reviews and discussions before integration into the main codebase. However, traditional pull request practices often fall short due to issues like feature creep, unintentional dependencies, knowledge silos, lack of context, and review bottlenecks, which can slow development and increase tech debt. To address these challenges, implementing best practices such as writing smaller and more focused pull requests, using PR stacking, providing ample contextual details, and encouraging real-time collaboration can enhance the efficiency and effectiveness of the pull request process. Additionally, involving diverse expertise, balancing team bandwidth, and integrating automation throughout the workflow can help teams maintain high productivity and collaboration. Tools like Graphite can further streamline and automate the process, allowing developers to focus on high-value tasks and enabling teams to continuously improve their pull request practices through metrics-driven experimentation and knowledge sharing.
Nov 09, 2025
2,460 words in the original blog post.
Ana's team experienced a major incident due to inadequate code reviews on a complex feature change, highlighting the importance of effective code review processes. The text explores various code review methods, including formal reviews, lightweight reviews, and pull request-based reviews, emphasizing the benefits and drawbacks of each. Formal reviews are thorough but time-consuming, while lightweight reviews, such as pair programming and asynchronous reviews, offer flexibility and speed but may lack depth. Pull requests, a staple in modern development, support collaboration and iterative feedback but can become cumbersome with large changes. Stacked pull requests, as facilitated by tools like Graphite, break down large changes into manageable pieces, enhancing review efficiency and code quality without blocking progress. The text suggests that while there is no one-size-fits-all solution, adopting a modern, change-based review process with tools that support stacked pull requests can significantly improve development velocity and accuracy.
Nov 09, 2025
2,821 words in the original blog post.
Graphite has introduced several updates and improvements over the past two weeks, focusing on enhancing user experience and collaboration features for its users. Key improvements include enhancements to the `gt get` and `gt sync` commands, allowing for smoother collaboration on stacks without unnecessary merge conflicts, and the addition of a keyboard shortcut for marking files as viewed. The platform is also hosting a series of webinars and live events, such as "Stacking 101" and a launch week featuring new product and feature announcements influenced by user feedback. Graphite has made it possible for bots and non-Graphite users to utilize the merge queue, facilitating automated merges, particularly useful for dependabot PRs. Additionally, users can now track pull request sizes over time, and the platform indicates when PR authors need to restack, ensuring efficient review processes. The team is seeking user feedback on experiences with continuous integration (CI) to further refine support for stacked PRs, inviting users to share their insights.
Nov 09, 2025
525 words in the original blog post.
AI coding assistants have sparked discussions among engineering leaders about their potential to accelerate development or possibly replace human developers, but current tools can't replace senior engineers, as they are limited by the context they can process and the complexity of tasks they can handle. Despite this, a significant majority of developers utilize AI to automate repetitive tasks like documentation and boilerplate code, enhancing productivity by allowing them to focus on more meaningful work, such as architecture design. This increased output, however, burdens the code review process, necessitating high-quality reviews. At Graphite, AI is being leveraged to streamline this process with an AI code reviewer that provides instant feedback on pull requests, catching bugs and suggesting improvements before human review. While this AI reviewer has improved over time, finding both minor and complex errors, human oversight remains essential to ensure high-quality software development. Graphite is actively refining its AI reviewer, viewing it as a tool to augment rather than replace human expertise, and is inviting interested parties to join its closed beta.
Nov 09, 2025
1,034 words in the original blog post.
Engineers are often pressured to develop software quickly, leading to rushed and over-engineered solutions that compromise quality and future adaptability. The text emphasizes the importance of building software with the minimum specifications and clean architecture to maintain speed without sacrificing quality. It advocates for simplicity by using narrow interfaces, clean coding patterns, and avoiding premature decisions regarding complex databases or frameworks, which allows for flexibility and easier future modifications. By sharing a cautionary tale of developing a to-do list app and an example from the development of FitNesse, the text illustrates the pitfalls of over-engineering and the benefits of deferring complex decisions until they are necessary. The core message is that high-quality, adaptable software can be achieved by prioritizing simplicity and cleanliness in coding, ultimately leading to faster and more efficient development.
Nov 09, 2025
1,872 words in the original blog post.
Anthropic's Claude Code has seen a 300% increase in usage over the past three months, but its ease in generating large amounts of code without clear author intent poses challenges for engineering teams. These challenges are exacerbated when AI-generated code results in extensive, complex pull requests (PRs) that are difficult to review and understand, leading to potential integration risks. To address this, the team at Graphite focused on teaching Claude Code to use stacked diffs, breaking down large PRs into smaller, manageable, and reviewable tasks. This approach aligns with engineering best practices, enhancing the clarity and reviewability of the code. The GT MCP framework was developed to help AI agents, including Claude, generate stacked PRs automatically, transforming large diffs into a sequence of smaller, focused pull requests. This framework has allowed Graphite engineers to build features, resolve bugs, and refactor code efficiently, while also contributing positively to the broader developer community by saving time and improving workflow.
Nov 09, 2025
1,054 words in the original blog post.
Graydon Hoare's blog post explores the challenges of maintaining a clean codebase free of bugs, emphasizing the "Not Rocket Science Rule of Software Engineering," which advocates for automatically maintaining code repositories that always pass all tests. The post highlights the issue of merge skew, where changes made by different engineers can conflict, leading to a broken main branch and reduced productivity. Hoare discusses solutions like Bors, an early attempt at an automated merge queue, which aimed to mitigate these issues by ensuring only passing code is merged. However, Bors struggled with throughput, prompting further innovations. Companies like Google have tackled these challenges by implementing systems that parallelize testing and batch processing of commits to maintain high throughput without sacrificing test coverage. Recent developments, such as GitHub's new merge queue feature, aim to bring similar high-efficiency solutions to a broader audience, enabling teams to merge code changes quickly while minimizing disruptions caused by merge conflicts.
Nov 09, 2025
2,941 words in the original blog post.
Graphite has introduced a new merge activity page designed to track the merge and commit history of repositories, which is crucial for documenting changes and identifying bugs or regressions. This feature is especially beneficial for organizations with merge queues enabled, as it provides a comprehensive view of the queue and its history. At Graphite HQ, live dashboards display real-time previews of merges into the trunk branch, enhancing visibility. Additionally, based on community feedback, code diffs have been made more readable in both light and dark modes by adopting a syntax highlighting scheme similar to GitHub's. The "merge when ready" feature is being revived, with a preview group available for those interested in testing it before its official release. There have also been minor user experience updates, including improved expand lines functionality in the diff view and added support for pinned function declarations in .tsx/.ts files, with plans for further language support.
Nov 09, 2025
201 words in the original blog post.
The exploration of AI-assisted code review, particularly using GPT-4, has demonstrated both the potential and limitations of integrating large language models (LLMs) into software development workflows. While GPT-4 can quickly generate reviews and highlight issues like spelling mistakes and minor logical errors, its accuracy is hindered by false positives and a lack of comprehensive codebase context. Efforts to improve AI review involved techniques such as introducing an "AI review guide" to align AI reviews with team preferences and using retrieval-augmented-generation (RAG) to provide better context. Despite these enhancements, the AI reviewer's signal-to-noise ratio remains insufficient, and philosophical concerns about aspects like author trust, reviewer learning, and accountability persist. Although AI may eventually serve as a supplementary tool by acting as a super-linter or providing contextual insights, human oversight and final approval are likely to remain crucial to ensure code quality and security.
Nov 09, 2025
1,196 words in the original blog post.
The code generation tool market is characterized by a competitive landscape with numerous players and no clear market leader due to the democratization of foundational large language models (LLMs) and open interfaces for logging code changes. These tools, which range from background servers to IDE extensions, cannot achieve a sustainable competitive advantage because the key resources—LLMs, interfaces, and contextual data—are widely accessible, and there are minimal barriers to entry. As a result, developers can easily switch between tools without incurring significant switching costs, and any innovative features are quickly replicated across the industry. The market mirrors economic theories of competitive markets where long-term excess profits are elusive, leading to a fragmented space where no single tool can dominate. Instead, developers prioritize flexibility and efficiency, selecting tools that best fit their workflows, which further diminishes the likelihood of a single tool achieving dominance. The future may see open-source solutions, such as tools powered by Meta's LLaMA, becoming "good enough" for most use cases, challenging the value proposition of proprietary tools in a commoditized market.
Nov 09, 2025
947 words in the original blog post.
Code reviews can be particularly challenging for distributed teams due to time zone differences, which often lead to delays and reduced productivity. Traditional workflows, like Gitflow, exacerbate this issue by limiting developers to one open pull request (PR) at a time, causing bottlenecks. The stacked PRs workflow offers a solution by allowing developers to create a series of smaller, logically separated PRs that build on one another. This approach enables parallel review and development processes, reducing wait times and enhancing productivity for teams spread across different locations. Stacking improves visibility of code changes, simplifies dependency management, and minimizes merge conflicts, as each segment of code is reviewed in isolation by domain experts. Tools like Graphite facilitate this workflow, offering features such as automated merging and rebase conflict resolution, which streamline the process and help maintain a stable main branch. Companies like Meta, Google, and Asana have successfully implemented stacked PR workflows, achieving significant time savings and improved code review experiences.
Nov 09, 2025
984 words in the original blog post.
Amazon Web Services (AWS) emphasizes automation and strategic deployment procedures to maintain its impressive service-level agreements (SLAs), which promise high uptime percentages, such as 99.9% for most services and up to 99.999% for others like DynamoDB Global Tables. Their automated incident management and deployment strategies include automated rollbacks, progressive rollouts, and slow rollouts (baking), which together minimize the potential impact of service changes and ensure high availability. These processes involve monitoring essential metrics and dependencies, implementing a "one-box" stage, and conducting deployments in waves to isolate potential failures. AWS also uses deployment blockers to prevent changes during critical times or active incidents, and pipelines for non-code changes like feature flags. Inspired by AWS, the startup Graphite has adopted some of these practices, such as extending pre-production bake times and timing deployments outside core business hours, while acknowledging the challenges of implementing AWS's scale-intensive processes.
Nov 09, 2025
1,415 words in the original blog post.
An official VSCode extension has been launched, enabling users to visualize and manage their code stacks directly within the Visual Studio IDE. This extension provides functionalities similar to the Graphite CLI, allowing users to create and modify branches, submit pull requests, and sync their trunk branch with robust support for stacking. Feedback is encouraged through the Community Slack server, as continuous iteration on the extension is planned based on user input. The initial support from preview users has been acknowledged and appreciated.
Nov 09, 2025
104 words in the original blog post.
In the world of software development, accurate project timeline estimates are crucial yet challenging due to pressures from various stakeholders, including product managers, business leaders, and even personal biases. When estimates are compressed due to external pressures, such as the desire to accelerate release timelines, it can lead to rushed development, resulting in incomplete features and customer dissatisfaction. The article suggests that engineering leaders should focus on maintaining accurate estimates and explore strategies such as reducing project scope and using productivity metrics to communicate effectively with non-technical stakeholders. It also emphasizes the importance of planning and modularizing projects to mitigate unforeseen delays, known as black swan events, and warns against the pitfalls of ego-driven underestimations. By striving to provide accurate and realistic estimates, engineers can help ensure smoother project flows and maintain trust within the organization.
Nov 09, 2025
2,569 words in the original blog post.
Graphite has introduced several new features and improvements aimed at enhancing engineering productivity and collaboration. These include the ability to automate workflows based on CI pass/fail triggers, allowing users to wait for CI success before adding reviewers or sending notifications. Users can also re-run only the failed CI jobs with a single click, saving time particularly when dealing with flaky tests. The platform now offers AI-assisted writing for pull request titles and descriptions, available both in-browser and via the terminal. Graphite has also made its mergeability check a required step to prevent reviewing outdated PRs, and it has improved collaborative features allowing seamless integration of remote changes to avoid merge conflicts. Additionally, a new merge queue feature supports parallel CI runs for multiple PRs, significantly speeding up merge times. These updates are part of a broader effort to streamline coding processes and are available in beta or general release, with some features requiring sign-up for access.
Nov 09, 2025
508 words in the original blog post.
At Graphite, a company initially lacking a robust testing culture, efforts over two years have successfully integrated testing practices into the development process, although challenges with poorly architected tests have emerged. Initially influenced by former engineers from Meta who carried over a lax attitude towards testing, the company has since shifted towards a more rigorous approach, emphasizing the importance of well-structured test architecture for maintainability. Drawing from lessons in "Clean Code," the narrative highlights the pitfalls of neglecting test quality, equating it to having no tests at all, as messy tests can hinder code evolution and increase maintenance burdens. To address these issues, Graphite has adopted strategies like refactoring code to separate logic from side effects, employing domain-specific languages to streamline test cases, parameterizing tests to reduce duplication, and designing tests with clear failure messages for easier debugging. These changes have not only improved test reliability but also optimized the test suite's performance, demonstrating that a disciplined and patient approach can substantially enhance a team’s testing culture.
Nov 08, 2025
2,977 words in the original blog post.
In the pursuit of faster development cycles, effective management of pull requests is crucial but often challenging, as they can become bottlenecks due to issues like merge conflicts and inadequate testing. A fictional company, DevApp Inc., illustrates how implementing best practices such as writing clear pull request descriptions, keeping pull requests small, ensuring collaborative code reviews, and using checklists can significantly enhance efficiency. By adopting dedicated tools like Graphite, which integrates with GitHub to streamline pull request processes, teams can automate testing, track performance metrics, and define service level agreements (SLAs) to maintain accountability and improve velocity. These systematic improvements enable teams to ship code faster without compromising on quality, thereby enhancing overall development productivity.
Nov 08, 2025
2,114 words in the original blog post.
As software engineering evolves with AI coding assistants like ChatGPT and GitHub Copilot, traditional code review practices are being challenged by the increased volume of code from both human and AI developers. An analysis of over 5 million pull requests from 35,000 engineers reveals that small companies ship code three times faster than larger organizations, largely due to their higher likelihood of skipping code reviews. TypeScript is gaining popularity among startups, while JavaScript's usage declines, and larger companies tend to use more established languages like Java and Python. Companies using monorepos face significantly longer merge times compared to those with multiple repositories, often due to the strategic organization of code rather than speed concerns. The ideal pull request size for expedited review is around 50 lines, as smaller PRs are merged much faster than larger ones. Additionally, CI run times tend to be twice as long at larger companies, and these organizations are more likely to use merge queues to streamline the process, although advancements in technology are allowing earlier adoption of these systems.
Nov 08, 2025
1,426 words in the original blog post.
Anthropic's release of their case study on the integration of their Claude model into Graphite Reviewer highlights the transformative potential of AI in code review processes. Initially, the development team faced challenges with existing large language models (LLMs) that failed to provide accurate and meaningful feedback, leading to doubts about the feasibility of AI-powered code reviews. However, Claude's ability to deeply understand code and offer valuable feedback with minimal false positives distinguished it from other models, leading to significant improvements such as a 40x faster pull request feedback loop and a 96% positive feedback rate. This enhancement allows developers to address issues like bugs and security vulnerabilities swiftly, particularly benefiting distributed teams working across different time zones. The partnership with Anthropic facilitated rapid scaling and technical support, underscoring the growing role of LLMs in enhancing software development efficiency and quality.
Nov 08, 2025
631 words in the original blog post.
The introduction of frozen branches in gt version 1.7.0 enhances collaboration in software development by allowing engineers to work on shared projects without the risk of inadvertently altering each other's work. A frozen branch remains in sync with remote updates but blocks local modifications, functioning as a read-only mode, which ensures stability and visibility. This feature is automatically applied when a branch is pulled using gt get, though users can toggle the frozen state with gt freeze or gt unfreeze commands. Frozen branches prevent accidental changes that could lead to merge conflicts, enabling teams to build on each other's work more confidently and efficiently. This update aims to streamline the development process by reducing errors and maintaining alignment among team members, thereby fostering a safer and more reliable collaborative environment.
Nov 08, 2025
653 words in the original blog post.
As data usage and traffic are expected to increase tenfold, a Node.js web app faced potential performance bottlenecks due to SQL query loads, prompting a need for optimization to handle the anticipated surge. Call site attribution was implemented to address this issue, allowing developers to trace SQL queries back to their source code for efficient identification and resolution of performance bottlenecks. Initial solutions using Datadog and monkey patching were deemed too costly or ineffective, leading to the adoption of a call site tagging system, which tags SQL queries with user-defined strings indicating their origin. This approach enhanced query traceability and system legibility without incurring additional costs, although it faced implementation challenges with the TypeORM library, which only partially supported query tagging. By wrapping TypeORM calls and using a query builder for tagging, nearly all queries were covered, allowing developers to identify and optimize problematic areas in the codebase effectively. This strategic implementation of call site tagging has positioned the app to manage its expected growth, ensuring ongoing optimization as user traffic continues to scale.
Nov 08, 2025
1,086 words in the original blog post.
Graphite has introduced Graphite Reviewer, an AI companion designed to enhance developer productivity by streamlining the review process of pull requests, now available as part of their platform used by engineers at companies like Snowflake and Asana. This tool aims to address the challenges posed by the rapid production of new code due to advancements in AI, offering instantaneous, high-accuracy feedback with less than a 3% false-positive rate. Integrated seamlessly into the Graphite dashboard and synced with GitHub, Graphite Reviewer uses Retrieval-Augmented Generation to provide context-aware feedback, detect bugs, and enforce custom codebase rules with no setup required. It is available for free in October, after which it will become a paid add-on. The tool has already proven to be a key component in improving workflow efficiency for both the Graphite team and external beta testers.
Nov 08, 2025
604 words in the original blog post.
Graphite shares their experience of migrating from Create React App (CRA) to Next.js, emphasizing the advantages of the latter for developing scalable and high-performance web applications. Initially, the migration was challenging due to their large TypeScript monorepo and collaborative environment, but consulting with Vercel and utilizing the App Router allowed them to streamline the process into five concise pull requests. They highlight key differences between Next.js and single-page applications, noting Next.js's support for multiple rendering strategies, automatic routing, and bundle-splitting, which optimize performance and improve user experience. Additionally, they discuss the benefits of server-side rendering for SEO and the growing trend towards using Next.js in modern web development due to its flexibility, scalability, and performance enhancements. Through their migration journey, they addressed issues like HTTPS in local development, SVG imports, folder restructuring, and server-side rendering complexities, ultimately demonstrating that transitioning to Next.js can be manageable and beneficial.
Nov 08, 2025
1,474 words in the original blog post.
In a rapidly evolving tech landscape, companies are striving to accelerate their software development processes, and while AI has improved the "inner loop" of code writing, the "outer loop" involving testing, reviewing, and merging remains a bottleneck. Organizations face the choice of building custom in-house tools or adopting commercial solutions like Graphite's AI-powered code review platform to enhance productivity. Building in-house offers customization and control but comes with hidden costs, scalability challenges, and resource diversion, whereas commercial tools offer scalability, security, and continuous updates. Graphite aims to streamline the outer loop by providing features such as AI-driven code reviews, seamless PR stacking, efficient merging through a merge queue, and data-driven insights to enhance team performance, allowing engineering teams to focus on delivering value to customers without the burdens of maintaining internal tools.
Nov 08, 2025
1,175 words in the original blog post.
Graphite has introduced the Graphite Agent, a unified platform that combines AI code review and Graphite Chat, allowing users to review, edit, and merge code directly within pull requests. The new tool, which integrates AI-driven PR reviews for instant feedback and conversational editing, replaces the former "Diamond" name and streamlines the entire code review process by enabling developers to create, review, and merge PRs in one place with stack-aware merge queue handling. The company has also updated its pricing plans to include a free Hobby plan for personal projects, a Starter plan at $20 per user per month for small teams, and a Team plan at $40 per user per month with unlimited features and automations, offering a 30-day free trial of the Team plan without requiring a credit card. Existing customers will transition to the new Team plan upon renewal after January 8, 2026, with the option to switch plans anytime prior. Additionally, Graphite's CLI version 1.7.1 includes new features like the ability to manage commit authorship, retrieve PRs opened outside of Graphite, and improved terminal compatibility, enhancing control and developer ergonomics.
Nov 08, 2025
323 words in the original blog post.
AI coding tools are revolutionizing software development by allowing developers to rely on large language models to generate code quickly, a process known as "vibe coding," which boosts productivity but presents challenges like logic errors, security vulnerabilities, and technical debt. This method, while efficient for rapid prototyping, can lead to complexities in the software development lifecycle due to unfamiliar code and the potential for unchecked errors. To address these challenges, integrating AI into the code review process has become essential, with tools like Graphite Agent facilitating responsible AI-assisted development by automatically detecting issues and providing actionable feedback. This hybrid approach of combining AI-powered and human reviews enables teams to maintain high-quality standards while benefiting from faster iterations, ensuring that both productivity and software quality are optimized.
Nov 08, 2025
1,044 words in the original blog post.
In 2011, Google faced the challenge of scaling its source control system, which relied on a single Perforce server that had been in use for over a decade, supporting thousands of users and millions of commands daily. Despite the server's remarkable performance, it was stretched thin, prompting Google engineers to explore alternatives. The decision to maintain a monolithic repository was significant, as it set industry standards for handling code complexity at scale. After rejecting alternatives like SVN due to migration issues, Google developed Piper, a distributed system built on Google infrastructure like Bigtable, to replace Perforce. This migration, which took over four years, was complicated by dependencies on the Perforce API, leading to a clean room design approach to avoid legal risks. The transition to Piper was critical, as it was an all-or-nothing move, requiring complete migration before Google could benefit from the new system. The successful cutover in 2012 reduced Google's operational risk and enabled new systems, highlighting a period of innovative and daring engineering at Google.
Nov 08, 2025
1,581 words in the original blog post.
Graphite has introduced several new features and improvements designed to enhance CI-based workflows and reduce associated costs, with updates including the ability to set up CI automations using templates, batch merges, and a CI optimizer to skip redundant runs. Users can now create automation rules based on the CI status of pull requests, reducing the number of unnecessary CI runs and associated costs. Additionally, fixes have been made to improve the user experience, such as correcting erroneous scrolling on the PR page and clarifying inbox displays. Graphite is also hosting a range of events, including a learning session, a happy hour in NYC, and a launch week filled with product and feature announcements. These initiatives aim to improve engineering velocity and developer satisfaction across organizations, as evidenced by a case study involving Asana engineers.
Nov 08, 2025
539 words in the original blog post.
Stacked pull requests (PRs) can greatly enhance a software development workflow by allowing developers to manage and review changes more efficiently. The approach involves organizing code changes into stacks, which can be based on functional components, iterative improvements, refactoring, version bumps, or riskiness. This method allows developers to focus reviews on specific parts of the code, such as separating database changes from front-end changes, and facilitates the integration of feedback with minimal disruption. Additionally, stacked PRs enable developers to address issues like bug fixes and version updates by isolating these changes, which helps in maintaining clarity during code reviews and simplifies the process of reverting risky changes if needed. Key strategies for effective use of stacked PRs include merging changes frequently to catch integration issues early, restacking on the main branch to avoid conflicts, and only stacking related changes to prevent delays. By implementing these techniques, developers can streamline their development cycles and enhance code quality.
Nov 08, 2025
1,148 words in the original blog post.
When merging pull requests on GitHub, choosing the right strategy from "merge commit," "squash and merge," or "rebase and merge" depends on the project's goals and the importance of preserving commit history. The "merge commit" option maintains a complete audit trail, beneficial for open-source projects that prioritize transparency, while "squash and merge" simplifies history by consolidating branch commits into a single commit, ideal for keeping a clean project history. The "rebase and merge" strategy, which replays branch commits onto the main branch, is suited for teams that value a linear commit history but can lead to conflicts and loss of original timestamps. To enhance workflow efficiency, some companies are adopting "stacking" workflows, which involve breaking large tasks into smaller increments and integrating changes frequently to maintain a clean, linear history, with tools like Graphite automating the process. Each strategy comes with its own set of advantages and challenges, and selecting the best method involves weighing factors such as commit history requirements, repository type, and team preferences.
Nov 08, 2025
2,450 words in the original blog post.
Graphite transitioned from a simple SPA deployment to a more sophisticated containerized environment using AWS ECS to enhance their Next.js application's scalability, performance, and cost efficiency. Initially hosted on S3 with CloudFront, they faced limitations as their platform and user base expanded, prompting a shift to Next.js for faster build times and bundle splitting. Despite Vercel and AWS Amplify being potential hosts, Graphite opted for AWS ECS due to its ability to unify frontend and backend hosting strategies, facilitate blue-green deployments, and maintain security within their AWS VPC. This move allowed them to leverage Amazon's infrastructure for consistent performance and easy scaling, while keeping costs manageable. They emphasize the importance of optimizing cold starts, automating infrastructure with Terraform, and regularly reviewing resource utilization to maximize cost efficiency. Graphite's journey underscores the necessity of evaluating infrastructure needs, embracing containerization, investing in automation, and remaining adaptable to new technologies in a rapidly evolving tech landscape.
Nov 08, 2025
1,550 words in the original blog post.
Graphite has introduced a new integration with Linear, allowing developers to manage issues directly within the Graphite web app without having to switch between the two platforms. This integration is designed to maintain context and focus by enabling developers to view, link, and create Linear issues directly from pull requests (PRs) in Graphite, reducing distractions and streamlining workflows. It is particularly beneficial for managing larger projects and bug reporting, as users can track progress and ensure that bug fixes have the appropriate context, thus enhancing software quality. The integration offers a unified issue tracking system where all related Linear issues are visible in the PR sidebar, and also allows for efficient bug reporting by linking bugs to the correct PRs. To get started, users need to connect their Linear accounts to Graphite, after which they can manage issues seamlessly from the PR pages. This partnership aims to improve the development process by helping teams quickly identify and resolve issues, fostering better collaboration, and ultimately achieving a more robust codebase.
Nov 08, 2025
399 words in the original blog post.
When the Phabricator team ceased development in 2021, it left a significant gap in developer tools, especially for teams reliant on its pioneering code review workflows. Phabricator's principles emphasized flexible draft changes, peer feedback before merging, and controlled releases, fostering an environment of experimentation and collaboration. However, with the rise of modern integrated ecosystems, transitioning away from Phabricator has become necessary. The article explores how developers can recreate Phabricator's workflow using Graphite, a modern, integrated platform that consolidates coding, reviewing, and tracking processes, thereby eliminating context switching and enhancing productivity. Graphite, which integrates seamlessly with tools like GitHub, Slack, and VS Code, offers features like stacked pull requests and interactive reviews, allowing teams to maintain Phabricator's collaborative spirit while benefiting from contemporary technology. This transition not only preserves the valuable cultural philosophies Phabricator introduced but also leverages modern tech to enhance development practices, offering a streamlined, efficient alternative for today's engineering teams.
Nov 08, 2025
2,194 words in the original blog post.
Graphite has significantly enhanced its VS Code extension, initially released in beta in September 2023, to improve the stacking workflow for developers by integrating it directly into their preferred editor environment. The extension, now generally available, allows users to visually manage stacks, create and move branches, and apply labels and reviewers across entire stacks, promoting seamless workflow transitions without relying heavily on terminal commands. The development process involved extensive feedback from the community, resulting in a product that enables both Git novices and stacking experts to efficiently master the stacking workflow. Key features include switching default branch views, tracking branches via the GUI, and viewing changes by commit or version. This integration aims to reduce tool sprawl and meet users where they are comfortable, further demonstrating Graphite's commitment to enhancing user experiences in code stacking.
Nov 08, 2025
653 words in the original blog post.
Graphite remains relevant in the evolving landscape of AI-driven code generation by focusing on enhancing the "outer loop" of software development, which involves code review, testing, and deployment processes. Despite AI tools like GitHub Copilot and ChatGPT generating an increasing volume of code, human oversight remains essential due to AI's shortcomings in code correctness and security. As AI-generated code increases the throughput of changes, the developer toolchain must adapt to manage a higher volume of pull requests, optimize CI pipelines, and streamline code review processes. Companies like Graphite are developing tools to handle these challenges by enabling efficient management of the development lifecycle, supported by generative AI that assists in summarizing and prioritizing tasks. This approach ensures that developers can continue to ship code quickly and safely, even as AI takes on a larger role in code generation.
Nov 08, 2025
1,584 words in the original blog post.
Graphite is a new, modern code review platform designed to enhance the efficiency and enjoyment of the code review process for fast-paced software teams. Originating from a need for more powerful tools than those available at major tech companies, Graphite emphasizes features like stacked changes, allowing developers to break down large tasks into manageable, independently testable, and reviewable segments. This approach helps authors get faster, higher-quality feedback and allows reviewers to focus on comprehensible changes, reducing re-review time and facilitating easier troubleshooting. Inspired by the shutdown of Phabricator, Graphite offers a streamlined, customizable interface with features such as a keyboard-first workflow, quick response times, and engaging elements like gifs to make code review less tedious. By storing all pull requests and reviews directly on GitHub, Graphite enables individual use without requiring team-wide tool changes, and is currently inviting users to join its private beta to help redefine code review standards.
Nov 08, 2025
635 words in the original blog post.
Graphite has introduced several updates aimed at enhancing user experience and efficiency. The new Graphite Chat feature, integrated into the pull request (PR) page, allows users to receive explanations on code changes, suggested fixes, and apply updates seamlessly, reducing the need to switch contexts and eliminating the dependency on an integrated development environment (IDE). Additionally, PR pages now load twice as fast, minimizing wait times and improving workflow continuity. The command-line interface (CLI) tool has been updated with new commands such as 'gt freeze' and 'gt unfreeze' for better branch management, alongside various fixes that address issues like branch synchronization and error handling. These enhancements collectively enable users to identify bugs, review PRs more efficiently, and manage branches with less manual intervention, promoting the shipping of cleaner code.
Nov 08, 2025
359 words in the original blog post.
Graphite has recently introduced several updates and features aimed at enhancing user experience and efficiency in managing pull requests and code reviews. The newest CLI release 1.2.8 includes a beta feature for AI-generated PR titles and descriptions, improved handling of branch names, and new flags for editing PR titles and descriptions. Additionally, fixes have been made for YubiKey-protected SSH key issues and improved dashboard performance. Users can now enjoy quicker review actions through an updated Review Bar, the ability to re-run only failed CI jobs with one click, and enhanced stack visualization for better code review context. A new feature indicates when CI failures in lower stack PRs affect those higher up, and the merge queue now supports parallel CI to expedite the merging process. These updates are part of a broader effort to streamline workflows and reduce the time to merge, with some features currently in beta testing and gradually being rolled out to users.
Nov 08, 2025
540 words in the original blog post.
Linus Torvalds created Git in 2005 due to a licensing dispute with BitKeeper, quickly establishing it as the world's most widely used version control system (VCS) owing to its distributed model, branch merging, and commit tagging features. Git's architecture comprises four key object types—blobs, trees, commits, and tags—and operates across three processing spaces: the working area, staging area, and repository, each playing distinct roles in managing code changes. Understanding Git's internal mechanisms, such as the differentiation between porcelain and plumbing commands, allows developers to navigate its functionalities more confidently and efficiently. Git's adoption has significantly increased, with surveys indicating a growth from 69% in 2017 to 94% in 2021, reflecting its dominance in the VCS landscape. The system's dynamic nature is further exemplified by branches, which serve as evolving references to commit series, automatically updating to the latest commit and facilitating a flexible development workflow.
Nov 08, 2025
2,316 words in the original blog post.
The text explores the fascinating dichotomy between rapid and slow code deployment and project release times, highlighting examples from both ends of the spectrum. In its early days, a messaging company used a remarkably fast deployment method by directly syncing new files to production servers, maximizing speed but eventually moving on from this technique. On the other hand, the text delves into some of the slowest pull requests and software projects, such as a PR that took 1857 days to merge and the decades-long development of GNU Hurd, illustrating how such delays can occur even in well-known repositories. The discussion extends to historically slow software projects like IBM's OS/360, WinFS, and Apple's Copland, emphasizing the lessons learned in modern engineering practices that prioritize speed and iteration. The narrative concludes with an optimistic view of the future, pointing to advancements in CI/CD workflows and tools like Graphite that foster quicker development cycles, thus reducing the likelihood of prolonged stagnation in software projects.
Nov 08, 2025
1,306 words in the original blog post.
Graphite, a software engineering tool aimed at optimizing developers' workflows, has unveiled its roadmap to enhance efficiency and user experience. Key upcoming features include "gt absorb," designed to streamline code changes and maintain a clean git history by automatically amending commits, reducing the time spent on manual tasks. Graphite also plans to integrate advanced automation capabilities, allowing developers to control continuous integration processes and trigger actions based on code patterns in pull requests. This will help in quickly resolving issues and maintaining smooth operations. To further expedite merging processes, Graphite introduces a merge queue and Parallel CI, leveraging speculative execution to handle multiple branches simultaneously, ensuring a stable mainline. Additionally, new insights will provide metrics on shipping smaller pull requests, and a revamped navigation experience is already available to enhance usability. Lastly, Graphite is preparing a comprehensive State of Code Review report, analyzing data from millions of pull requests to understand and improve practices across the software development community.
Nov 08, 2025
871 words in the original blog post.
Git reflog is a powerful tool that acts as a chronological logbook for a Git repository, recording all changes made to the HEAD pointer and enabling developers to undo mistakes by navigating through the repository's history. It stores every modification, allowing users to rewind time and recover from errors such as accidental commits, deleted branches, or botched rebases. Stored in the .git directory, reflog can be accessed and filtered using time qualifiers to pinpoint specific moments in a project's history. This capability is crucial for correcting mistakes like a failed rebase by identifying the correct commit to revert to. While reflog is not a substitute for good engineering practices, it can be a lifesaver in worst-case scenarios, providing a way to restore a repository to a desired state when things go awry.
Nov 08, 2025
1,367 words in the original blog post.
AI code generation tools are advancing rapidly, enhancing software development speed but also presenting challenges in maintaining code quality. The increasing volume of code necessitates efficient review processes, where AI-powered tools like Graphite Agent can play a crucial role. These tools streamline code review cycles by automating repetitive tasks, reducing human bias, and providing immediate feedback, thus allowing developers to focus on high-priority work and creative problem-solving. Traditional code reviews can be time-consuming and prone to errors, but AI can mitigate these issues by detecting bugs, security vulnerabilities, and performance inefficiencies early in the process. This not only accelerates review times but also minimizes context switching and cognitive load for developers. Graphite Agent, in particular, enhances productivity by offering context-aware feedback and facilitating asynchronous collaboration across time zones through its Graphite Chat feature. As AI-driven tools continue to evolve, they are becoming integral to development workflows, enabling teams to deliver high-quality code efficiently and effectively.
Nov 08, 2025
1,304 words in the original blog post.
The narrative recounts an engineer's journey from struggling to advance from an L4 to an L5 engineer at Airbnb to founding a startup and realizing the importance of trust and dependability in engineering roles. Initially, the engineer focused on working hard and solving immediate problems, but failed to meet project goals due to a lack of accountability and communication, resulting in a harsh performance review. This experience underscored the importance of trust and reliability in delivering complex projects and led to a shift in perspective when founding a startup, where hiring decisions emphasized senior engineers capable of consistently shipping challenging projects. The engineer reflects on the significance of building trust through a streak of reliability, arguing that dependability outweighs unreliable excellence, as trust is crucial in managing high-stakes projects within the broader scope of company operations. The narrative concludes with advice on focusing on being a dependable engineer and maintaining reliability to advance in one's career and contribute effectively to a team.
Nov 08, 2025
1,456 words in the original blog post.
Graphite has introduced a highly-requested feature that automatically rebases stacked pull requests after partial merges, enhancing the workflow for users by eliminating the need to manually run rebase commands. Previously, merging parts of a stack on Graphite required additional steps to update the remaining pull requests, which could lead to inaccurate code diffs and workflow issues on GitHub. With this update, the Graphite platform now manages the rebasing process automatically, ensuring that code diffs are always accurate and eliminating the risk of assigning incorrect reviewers to pull requests. This seamless integration requires no new tools or commands, as Graphite's CLI detects and applies remote updates to local branches, effectively collaborating with users' workflows and maintaining consistency across development environments. This feature builds upon the recent announcement of shared stacks and is now available to all organizations using Graphite.
Nov 08, 2025
500 words in the original blog post.
Graphite is evolving its AI code review tools by combining its AI reviewer, Diamond, and chat functionalities into a unified platform called Graphite Agent, which facilitates seamless collaboration on pull requests. This new tool aims to provide developers with an integrated experience where they can create, review, and merge code in one place, enhancing efficiency by offering instant feedback and suggestions directly in the code diff. The update reflects Graphite's belief that AI should be a fundamental component of modern development tools, accessible to all developers regardless of team size or budget, with new pricing plans introducing a free hobby plan, a $20 starter plan, and a $40 team plan. Existing customers will transition to the new Team plan by January 2026, and a 30-day free trial is available for new users. The introduction of Graphite Agent underscores the need for tools that can keep pace with the rapid code generation capabilities of AI, aiming to make code review more efficient and collaborative.
Nov 08, 2025
703 words in the original blog post.
In the current AI-driven landscape, companies are increasingly integrating AI features into their products, often as a marketing strategy, but not all these features are effective or valuable. Good AI features are defined by their ability to offer low-friction user experiences and leverage unique data that only the product can access. This is evident in products like GitHub's Copilot, which excels by providing seamless AI responses, and Notion's AI search, which operates over proprietary data. Effective AI integration requires that a product already delivers value without AI, ensuring that AI features enhance rather than define the user experience. Additionally, AI features that excel usually have access to unique datasets, allowing them to offer insights or automation that other platforms cannot replicate. Examples from Graphite highlight these principles in action, showcasing AI-generated branch names as a feature that reduces user effort while utilizing unique data. As AI technology evolves, these principles may shift, but the current focus remains on reducing friction and utilizing proprietary data effectively.
Nov 08, 2025
1,597 words in the original blog post.
As the year-end approaches, many development teams face a code freeze, a period during which no new code changes are allowed to ensure stability and minimize risks in production. This often leads to engineers feeling blocked, with tech debt accumulating and backlogs growing. Stacking, a technique popularized by companies like Meta and Google, offers a solution by allowing developers to break their work into smaller, dependent pull requests (PRs) instead of large, monolithic ones. This approach enables continued development and review even during a code freeze, as the smaller PRs are easier to manage, review, and merge once the freeze is lifted. Stacking not only maintains productivity during code freezes but also simplifies reviews, reduces risks, and accelerates delivery timelines with faster, more thorough reviews and easier debugging and rollbacks. Although especially beneficial during code freezes, adopting stacking as a regular practice encourages writing small, atomic PRs that keep teams unblocked throughout the year.
Nov 08, 2025
624 words in the original blog post.
AI cannot fully replace human code review due to the fundamental differences between code creation and review, as well as the need for context, pedagogy, collaboration, security, and accountability that only human engineers can provide. While AI-powered tools can assist by handling routine scanning tasks and flagging potential issues, they lack the capability to offer the deep understanding, strategic insight, and accountability that human reviewers bring to the table. AI's role is best viewed as an advanced form of continuous integration, offering support rather than serving as the ultimate authority. Human involvement remains crucial to ensure effective code review, foster collaborative learning, and maintain accountability, especially as AI-generated code becomes more prevalent. The future is likely to feature AI-assisted processes with humans maintaining the final decision-making power.
Nov 08, 2025
1,741 words in the original blog post.
Jane's experience illustrates the significant challenges faced by engineering teams as they grow, particularly regarding the overwhelming volume of GitHub notifications and its impact on productivity. As teams expand, unmanaged pull request (PR) notifications can disrupt workflow, reduce focus, and obscure critical updates. GitHub's existing tools, while initially useful, struggle to scale with increased team sizes, leading to fragmented visibility and the risk of important issues slipping through the cracks. Graphite emerges as a solution, offering a consolidated platform to manage the PR lifecycle efficiently, featuring custom filters, noise reduction, Slack integration, and advanced analytics. This tool is designed to streamline notification management and enhance productivity for engineering teams dealing with high notification volumes, providing a more focused and efficient work environment.
Nov 08, 2025
1,654 words in the original blog post.
Almost three years ago, the author left Facebook to join a fledgling startup with just five employees, motivated by a desire to learn more quickly in a smaller team environment. Initially, the author feared technical challenges, such as a failed database migration without the safety net of a large infrastructure team, and worried about scaling issues due to limited user numbers. However, these fears were largely unfounded, as the startup's early adopters were forgiving and engaged, willing to provide feedback and help improve the product. The reality was that technical challenges arose more gradually, allowing the author to build expertise over time, exemplified by a two-year journey to solve a database issue caused by a leftover replication slot. This experience highlighted the stark contrast between launching products at big tech firms, where user expectations are high and immediate, and building at a startup, where gaining users and their trust is a more gradual and collaborative process. Ultimately, the author stresses that while the work is challenging and becomes increasingly difficult as a startup grows, the technical hurdles are manageable with a willingness to learn and adapt.
Nov 08, 2025
932 words in the original blog post.
In software development, particularly in Git-based workflows, developers often face the choice between merging and rebasing when integrating changes from one branch into another, with the latter gaining traction among fast-moving companies due to its ability to maintain a cleaner and more understandable project history. Trunk-based development, which emphasizes a single source of truth and short-lived branches, is becoming more popular, especially in closed-source development environments, as it simplifies integration and reduces the complexity associated with long-lived branches. Rebasing, although initially daunting due to the intimidating nature of rebase commands and the potential for "force push" events on platforms like GitHub, offers significant advantages, such as easier reversion of changes and a tidier commit history. The trend towards rebasing is evident, with large repositories increasingly banning merge commits in favor of a squash-rebase-and-merge workflow, driven by tooling advancements like Phabricator and Graphite that automate and simplify the rebasing process. Despite its challenges, rebasing is being embraced by large tech companies and startups for its efficiency and cleaner workflow, marking a shift in industry practices.
Nov 08, 2025
1,009 words in the original blog post.
Building a code search tool for Graphite Chat required overcoming limitations of traditional search methods like grep when applied to large repositories with numerous files and commits. The challenge lay in supporting fast searches across any commit without extensive resource use. While initial attempts with AWS storage solutions and Elasticsearch showed potential, they were insufficient for indexing vast repositories at every commit. The breakthrough came by adopting a Git-like approach, storing data as blobs and trees, which allowed efficient search queries by matching blob IDs with trees for specific commits. This method enabled fast, commit-agnostic searches with median latency under 100 milliseconds, significantly improving upon previous GitHub API reliance. The innovative indexing system is now live, indexing millions of files and serving thousands of queries efficiently, with further enhancements anticipated, such as semantic search capabilities.
Nov 08, 2025
1,843 words in the original blog post.
Modern software development teams face challenges in managing codebases across diverse time zones, cultures, and expertise levels, with tools like GitHub and Phabricator historically assisting in repository management and workflow optimization. GitHub, widely used for its cloud-hosted environment and traditional functionality, offers managed services that reduce overhead compared to self-hosted options like Phabricator, which, despite its powerful stacked pull request workflow, requires significant setup and maintenance effort. Graphite emerges as a solution that enhances GitHub by integrating Phabricator's efficient stacking workflow, facilitating smaller, more manageable pull requests, thereby improving developer productivity and code quality without the complexity of self-hosting. While Phabricator allows for extensive customization, its lack of active maintenance and support poses challenges, making Graphite a favorable alternative for teams seeking the benefits of modern workflows without extensive overhead. Cost-wise, GitHub and Graphite offer subscription models that balance functionality with affordability, whereas Phabricator could incur higher lifetime maintenance costs despite being free to install. Ultimately, the choice between these tools depends on a team's specific needs, with Graphite offering a compelling middle ground by optimizing GitHub's capabilities to enhance developer efficiency and streamline code reviews.
Nov 08, 2025
2,137 words in the original blog post.
The decision by Facebook to adopt Mercurial over Git for their version control was driven by performance considerations and the collaborative nature of the Mercurial community, as detailed in a narrative recounting the company's migration process in the early 2010s. Initially, Facebook faced performance issues with Git due to the scale of their codebase, which led them to explore alternatives, including Mercurial, which offered a cleaner architecture and extensibility. Despite initial resistance from Git maintainers to improve performance for large repositories, Facebook found Mercurial's community more open to collaboration, which, coupled with the system's ease of extensibility, made it a suitable choice. The transition was managed through careful internal communication and alignment with the engineering team, emphasizing the human and collaborative elements in technical decision-making. This strategic migration not only improved Facebook's handling of large monorepos but also led to the development of novel workflows like "stacked diffs," which later influenced other companies and inspired efforts to integrate similar features into Git.
Nov 08, 2025
1,905 words in the original blog post.
AI advancements have revolutionized code writing, enabling individual developers to generate code rapidly, which has highlighted the need for tools to expedite the rest of the development lifecycle. Graphite addresses this need by introducing Graphite Chat, a new feature that integrates seamlessly within pull requests to facilitate interactive code reviews. This tool allows developers to chat directly within their pull requests to ask questions, understand code changes, and receive customized suggestions and fixes, effectively transforming code review into a conversational process. Graphite Chat, currently in beta and free for all users, provides instant, context-aware assistance for both authors and reviewers, supporting a streamlined workflow from comment to commit without the need for multiple context switches. It offers the ability to ask questions about unfamiliar code, ensure adherence to coding patterns, and identify potential issues such as test failures or security concerns, ultimately aiming to enhance efficiency and code quality in software development.
Nov 08, 2025
700 words in the original blog post.
Graphite, a company that developed a successful code review platform, learned crucial lessons on product development through failures and pivots, ultimately succeeding by focusing on real user needs. The founders initially created tools like a "bug capture" tool and iOS rollbacks that failed to gain traction because they did not address significant pain points. The key turning point was embracing "The Mom Test," a concept from a book that emphasizes asking unbiased questions to understand genuine user needs, rather than relying on positive feedback from supportive peers. By focusing on existing demands and acknowledging solutions already in use, Graphite found success with its code review tool, which was already desired by developers at large companies like Google and Facebook. Through this iterative process, the importance of identifying actual user problems and ensuring a product's relevance became clear, illustrating the value of seeking honest feedback in product development, particularly within the DevTools sector.
Nov 08, 2025
1,297 words in the original blog post.
Continuous Integration (CI) is crucial in modern software development for automating code checks and facilitating efficient code reviews, but the duration of CI processes can impact productivity. A study by Graphite revealed that while shorter CI times are generally preferred, a paradox exists where CI times between 15-30 minutes correspond to the highest number of merged pull requests per author. This suggests that these durations may strike a balance between complexity and optimization. The "10-minute golden rule" is often cited as ideal, but data shows that longer CI durations can still be effective, particularly if teams employ strategies like stacking pull requests to maintain velocity. Ultimately, the goal is to find an optimal CI duration that accommodates the complexity of the product while ensuring efficient workflows, with the understanding that reducing CI time can significantly decrease time-to-merge.
Nov 08, 2025
935 words in the original blog post.
Code review has significantly evolved from its inception in the 1970s, initially introduced as "Fagan Inspections" by IBM engineer Michael Fagan, who emphasized error detection without room for design discussions. Through the decades, the practice transformed from cumbersome in-person evaluations to self-reviews known as desk checks in the 1990s, albeit adopted by only a minority of developers. The shift to digital in the early 2000s, driven by advancements in source control systems like Git, enabled global collaboration and led to the creation of Google's Mondrian, a pioneering web-based code review tool by Guido van Rossum. Mondrian's user-centric design, inspired by Gmail, focused on actionable code reviews. This evolution continued with the rise of GitHub, which adapted the code review process to prioritize open-source maintenance, showcasing repository-wide interactions and utilizing Pull Requests to foster collaborative discussions. Today, code review is an integral part of software engineering, with distinct systems catering to both open-source and closed-source environments, reflecting its journey from a niche practice to a cornerstone of code quality assurance.
Nov 08, 2025
764 words in the original blog post.
Graphite has introduced "Graphite for Startups," a new program designed to provide early-stage companies and open source projects with free access to its full Standard plan, which includes features such as unlimited stacking, insights, automations, and a stack-aware merge queue. Aimed at startups with 10 or fewer GitHub organization members, this initiative seeks to empower fast-moving software teams by equipping them with effective tools for code creation, review, and merging, thus enhancing their ability to iterate quickly and achieve product-market fit. The program also extends to open source project maintainers, reflecting Graphite's commitment to supporting the open source community by offering them the same advanced tools used by top enterprise software teams. To join, eligible startups and OSS projects need to sign up for an annual Graphite Standard plan, with automatic eligibility detection and activation of the free subscription, while larger OSS projects can contact Graphite for potential discounts.
Nov 08, 2025
496 words in the original blog post.
Stacked pull requests (PRs) offer a strategic solution for managing large code changes by dividing them into smaller, focused PRs, enhancing the efficiency and speed of software delivery. This approach allows developers to work on subsequent tasks without waiting for the review and approval of prior ones, thus preventing bottlenecks in the workflow. Each small PR is independently reviewed and merged, facilitating quicker, more thorough reviews, and simplifying debugging by isolating changes. Traditional tools like GitHub can require tedious manual management of dependencies between branches, but tools like Graphite automate this process, handling branch coordination and visualizing dependencies, ultimately streamlining development. By adopting stacked PRs, teams can achieve faster innovation cycles, improved code quality, and greater overall productivity, while reducing the challenges and delays associated with large, monolithic PRs.
Nov 08, 2025
2,250 words in the original blog post.
Starting with Tower 13, the popular Git GUI client now natively supports Graphite, enabling developers to create, manage, and submit stacks of pull requests directly from the desktop application. This integration enhances the stacking workflow, allowing for visual and interactive management of branches, similar to Graphite's VS Code extension. The collaboration between Graphite and Tower focuses on making code changes faster to review, safer to merge, and easier to rollback by breaking monolithic features into smaller, incremental pull requests. Users can quickly set up the Graphite integration, which includes features like visual branch management, restacking, synchronization, and direct submission of pull requests to Graphite. Tower now supports Graphite's commands such as gt modify and gt sync, while also providing Graphite-aware warnings to prevent stack issues. This integration aims to make stacking a default workflow for developers, offering flexibility across different environments such as the CLI, visual PR Inbox, and GUI integration.
Nov 08, 2025
697 words in the original blog post.
As of October 2025, Graphite has deprecated the Diamond name, integrating its AI code review functionalities under Graphite Agent, aiming to enhance the productivity of AI-native IDEs and autonomous development agents by incorporating AI in the review, testing, and deployment processes. Graphite's AI-powered code review platform provides developers with instant feedback on code changes, automatically summarizes pull requests, and offers actionable code suggestions, enabling a seamless code review experience akin to the workflows at Meta and Google. This platform is widely adopted by companies such as Shopify, Snowflake, and Figma, supporting fast-paced software teams. Graphite's recent $52 million Series B funding, led by Accel with contributions from Menlo Ventures, Shopify Ventures, and Figma Ventures, underscores its position as a leader in AI code review, with its standalone product, Diamond, offering customizable review features and universal GitHub integration, available for free for up to 100 pull requests per month. As AI continues to transform software development, Graphite is expanding its team, inviting talent to join its 30-person NYC-based team to further innovate in the field.
Nov 08, 2025
642 words in the original blog post.
Monorepos, used by major tech companies like Google and Meta, house millions of lines of code in a single repository, facilitating collaboration across vast engineering teams but also presenting challenges related to size and complexity. These companies employ "stacking," a workflow that breaks large changes into smaller, manageable pull requests to maintain productivity by allowing continuous parallel development and avoiding bottlenecks. The integration of specialized tools, such as Google's Bazel and Facebook's Phabricator, optimizes the codebase management and review process, while robust CI/CD workflows ensure seamless integration and delivery of code, minimizing deployment risks. These methodologies, traditionally employed by tech giants, are now accessible to smaller organizations through tools like Graphite, which democratize advanced workflows and enhance developer productivity regardless of team size. This comprehensive approach to software development, integrating monorepos, stacking, and CI/CD, exemplifies best practices for delivering high-quality code efficiently and reliably, offering valuable insights for teams of all scales.
Nov 08, 2025
1,126 words in the original blog post.
Graphite's engineering team stands out for its exceptional code throughput, significantly surpassing industry benchmarks in pull requests per engineer, attributed to their unique workflow approach. They utilize stacked pull requests, allowing engineers to work on multiple parts of a project simultaneously, thus avoiding bottlenecks and maintaining a consistent flow of code changes. This method, while resulting in a slightly longer median time-to-merge, ensures that engineers are never blocked and can continue development without delays. Graphite emphasizes that their remarkable pace is not achieved through overwork or extended hours but through efficient processes, trust, and the effective use of their productivity tools. The company showcases this approach not only as a testament to their productivity but also as a model that can inspire others to optimize their workflows without sacrificing code quality or team well-being.
Nov 08, 2025
1,030 words in the original blog post.
With Developer Week 2025 approaching, the Graphite team is preparing to engage with global developers in Santa Clara, showcasing their recent innovations and discussing software development best practices at booth 415. Attendees have the opportunity to explore Graphite's new AI features and receive exclusive merchandise. Additionally, Graphite is hosting a special breakfast event, "Stacks and Flapjacks," for senior engineers and leaders, with limited registration. A key session on February 12th will address the integration of AI tools in the "outer loop" of the software development lifecycle, focusing on enhancing the processes of testing, reviewing, merging, and deploying code. Participants can also arrange meetings with the Graphite team either at the conference or virtually to discuss product usage and support.
Nov 08, 2025
325 words in the original blog post.
Google employs two internal code review tools, Critique and Gerrit, to facilitate its software development process. While Critique is predominantly used internally by engineers, Gerrit is open-sourced for public-facing projects. Both tools offer sophisticated dashboards for managing change lists, with Gerrit focusing on a detailed view of change statuses and Critique allowing customization of dashboard sections. Notable features include test coverage metrics, commit message reviews, and visual differentiation of code changes. Google's review process also emphasizes a rigorous approval system, necessitating LGTM, code owner, and readability approvals before code can be submitted. This meticulous approach not only ensures code quality and adherence to standards but also fosters a culture of thorough and thoughtful reviews, supported by custom tooling that enhances efficiency. Despite the complexity, the review process is swift, often taking less than four hours, highlighting the effectiveness of Google's emphasis on code review compared to industry standards.
Nov 08, 2025
1,578 words in the original blog post.
Automated testing is crucial in software engineering to prevent regression and ensure functional correctness, but certain features, such as those involving third-party APIs and complex UI components, present challenges. At Airbnb, testing aspects like password reset emails proved difficult due to outsourced functionalities. The absence of automated tests in certain cases, driven by time constraints and business urgency, is not inherently negative, as it allows for quick validation and product iteration, although it risks accumulating technical debt. Various strategies, such as canary releases, beta cohorts, and dogfooding, provide alternatives to automated testing. Graphite's engineering team has adopted an innovative method by randomly deleting an engineer's account daily to test their onboarding process, revealing numerous bugs and creating user empathy. Despite the benefits, this approach has limitations, such as skipping certain onboarding aspects, and may not be suitable for all products. Ultimately, combining dogfooding with automated testing offers a comprehensive approach to identifying unknown issues and improving user experience.
Nov 08, 2025
1,267 words in the original blog post.
Graphite's engineering team, known for its fast-paced culture, faced challenges with frequent regressions due to rapid development and deployment cycles. To mitigate this, a staging environment was implemented at the end of 2022, allowing for pre-production testing and enabling the team to catch issues before they affected users. This setup involved creating a separate AWS account with duplicate infrastructure to test changes rigorously. Despite initial complaints about additional wait times and the complexities of maintaining two environments, the staging bake process significantly reduced production regressions and improved team confidence. Subsequent improvements included adding an emergency deployment pipeline, a manual skip-bake command, and controls to manage deployment timing, inspired by practices from Airbnb. The staging bake has proven beneficial, offering a buffer before production deployments and facilitating smoother handling of potential issues, ultimately enhancing the deployment process and overall product reliability.
Nov 08, 2025
2,395 words in the original blog post.
Graphite has introduced a new batch merging feature designed to enhance the efficiency and cost-effectiveness of its merge queue system, addressing a key demand from its most active customers. Batch merging allows multiple pull requests (PRs) to be grouped into a single draft PR, which undergoes continuous integration (CI) testing; if it passes, all PRs are merged together, thus optimizing throughput and reducing CI expenses. This approach contrasts with the previously implemented Parallel CI by prioritizing speed and cost reduction over ensuring every individual commit remains buildable, ultimately keeping the trunk branch stable post-merge. While batch merging can significantly accelerate queue times and lower costs, it may not be suitable for teams that require perfect commit history integrity. The feature, which is currently in public beta, offers customizable batch sizes and presents options for handling failed CI tests, such as removing the entire batch or bisecting to identify the problematic PR.
Nov 08, 2025
577 words in the original blog post.
Hack the North 2025 showcased the innovative approaches of students at the University of Waterloo towards software development, emphasizing collaboration and AI-enhanced tools. The event highlighted the use of Graphite to improve teamwork and code quality, introducing the "Graphite Dream Team" award to recognize projects excelling in both technical execution and collaboration. A standout project, "Tango," developed by Rachelle DeMan and Krish Krish, demonstrated the effective use of Graphite's features to enhance developer productivity. Students explored AI-powered tools like GitHub Copilot and Claude Code to expedite coding processes while maintaining the importance of human oversight in code review. Graphite played a pivotal role by offering structured AI code review capabilities, bridging the gap between AI-generated code and human quality assurance. The hackathon underscored the importance of mastering collaboration, project management, and tool integration, preparing students to navigate the evolving tech landscape as adaptable, forward-thinking engineers.
Nov 08, 2025
535 words in the original blog post.
As of October 2025, the AI code review tool formerly known as Diamond has been rebranded under the Graphite Agent, emphasizing its role within the Graphite platform. Originally launched as a standalone product, Diamond was separated from Graphite to improve accessibility, allowing teams using AI code generation tools like Copilot to integrate it into their workflows on GitHub, even if they don't use Graphite. Diamond offers free reviews for up to 100 pull requests monthly, making it an attractive option for startups. It enhances the "outer loop" of development—code review, testing, merging, and deployment—by drastically reducing code review times and offering customizable rules and feedback. While Diamond significantly improves code review efficiency, it reaches its full potential when used with Graphite's entire platform, which includes features like stacked pull requests, an automated merge queue, CI optimizations, and a unified PR inbox to streamline the development process. Diamond is available independently but also complements Graphite's comprehensive suite, aiming to enhance developer productivity and adapt to modern software development needs.
Nov 08, 2025
559 words in the original blog post.
Graphite's recent launch week unveiled several innovative features designed to enhance collaboration and efficiency for developers using its platform. Key announcements included the ability for multiple engineers to collaborate seamlessly on the same stack of pull requests (PRs) with enhanced Git state management, and automatic rebasing of partially merged stacks to ensure correct diffs and reviewer assignment. The introduction of Graphite merge rules allows teams to set customizable, flexible branch protection and code ownership requirements, enabling fast-paced development while adhering to company policies. Additionally, Graphite introduced batching to improve continuous integration (CI) processes, reducing costs and expediting merging by grouping PRs for simultaneous testing and merging. These updates are complemented by new integrations with Buildkite and GitHub Actions to optimize CI pipelines, offering more reliable releases with controlled costs.
Nov 08, 2025
528 words in the original blog post.
Monorepos are popular for enhancing developer velocity but pose challenges like merge conflicts and potential deployment issues as more developers contribute code to a single repository. To address these issues, merge queues can be implemented to ensure more predictable releases and reliable software by merging changes in a first-in-first-out order. However, long Continuous Integration (CI) times can slow down these queues, prompting the introduction of Parallel CI, which speeds up the process by running CI checks concurrently for multiple stacks. This approach maintains correctness while increasing throughput, allowing teams to merge more pull requests efficiently without compromising reliability. Parallel CI has shown significant improvements in merge times, with early adopters experiencing up to 2.5 times faster merges. Furthermore, Graphite's merge queue supports both Parallel CI and batching, providing flexibility in balancing correctness and CI cost efficiency. The implementation of Parallel CI is based on speculative execution, a concept used by companies like Uber, and allows for higher throughput by testing groups of pull requests simultaneously.
Nov 08, 2025
934 words in the original blog post.
Graphite has been experimenting with the integration of AI into engineering workflows to enhance productivity and efficiency, particularly in the create-review-merge developer process. Key successful experiments include automating the generation of Pull Request (PR) descriptions, which improved the quality of commit messages and facilitated easier review of past changes; generating weekly digest notifications summarizing codebase changes, which helped engineers stay informed; translating vague inline comments into actionable code suggestions, which expedited review cycles; and using a Q&A bot to streamline onboarding by providing thorough answers to new engineers' queries. Additionally, AI-driven PR reviews offered quick, systematic checks for code style and test coverage, reducing review cycles. However, not all initiatives were successful, such as fully generative documentation and descriptive notifications, which suffered from inaccuracies and lack of added value, respectively. Overall, these experiments underscore the potential of AI to accelerate development workflows while also highlighting the need for careful integration to maintain trust and effectiveness.
Nov 08, 2025
1,941 words in the original blog post.
Developers often face challenges in maintaining efficiency due to distractions and lack of visibility into project workflows, making it difficult to optimize processes. Tracking pull request (PR) metrics can provide valuable insights into workflow bottlenecks and help improve code quality and delivery speed. Key metrics such as time to first review, publish to merge time, review cycles, and throughput can highlight progress and participation issues. While GitHub offers APIs for accessing PR data, extracting and visualizing meaningful insights requires significant effort in data processing and maintenance. Graphite provides a streamlined alternative with out-of-the-box analytics that integrate seamlessly with GitHub, offering pre-aggregated metrics and automatic reporting without the need for custom development. This solution enhances visibility into developer productivity and collaboration, helping teams identify bottlenecks and make informed decisions to improve project health and efficiency.
Nov 08, 2025
1,346 words in the original blog post.
Engineering teams often face challenges with merging pull requests, particularly as they scale, due to the inefficiencies of traditional merge queues that do not account for dependent or "stacked" pull requests. Graphite tackled this issue by developing the first stack-aware merge queue, which treats stacks as interdependent units rather than individual pull requests, enabling more efficient merging processes. This innovative system has led to significant productivity improvements, such as a 74% reduction in merge times at Ramp and seven hours saved per engineer per week at Asana. The merge queue's architecture includes speculative execution, bisection algorithms for isolating failures, and partitioned queues to manage concurrent processes, all of which minimize CI resource waste and streamline the merging workflow. These enhancements enable teams to maintain high code quality without sacrificing developer velocity, thereby transforming the economics of software development by encouraging smaller, more reviewable pull requests and facilitating faster feature delivery.
Nov 08, 2025
3,457 words in the original blog post.
Graphite's approach to building developer tools emphasizes simplicity and developer velocity through a monorepo architecture using TypeScript, eschewing microservices and polyglot systems for a unified codebase. This strategy, inspired by experiences at Facebook and the principles of clean architecture, focuses on reducing software complexity by addressing change amplification, cognitive load, and unknown dependencies. Graphite's system prioritizes composition over complexity, employing dependency inversion and functional programming to maintain flexibility and testability. The company leverages a single server image for deployment, powered by a straightforward build system that uses Turbo to optimize build times, and employs a shared development environment to facilitate seamless onboarding. Infrastructure is managed with Terraform, allowing for comprehensive code review processes for both application and infrastructure changes. Graphite's architecture, though contrarian, is tailored to its specific needs, enabling its engineering team to rapidly ship features and maintain quality, with a focus on continuous improvement and developer experience.
Nov 08, 2025
2,777 words in the original blog post.
Many large tech companies, such as Google and Meta, have historically developed their own internal tools rather than relying on widely available platforms like GitHub, driven by a "not invented here" mindset and the desire for complete control and seamless integration with their existing systems. While companies like Airbnb and Stripe have embraced SaaS tools including GitHub, leveraging the rich ecosystem available today, giants like Google have developed custom tools like Critique and Gerrit for code review, offering features tailored to their specific workflows. These internal tools provide sophisticated functionalities such as customizable dashboards, multi-level approval processes, and attention sets for managing code review tasks, which could theoretically be replicated on GitHub through its robust API and platform capabilities, albeit with a less polished user experience. The decision to develop in-house solutions often stems from the era of a company's founding and its cultural tendencies, raising questions about whether the largest companies will continue this trend as they scale or adapt to using more external tools as they grow.
Nov 08, 2025
1,954 words in the original blog post.
Continuous integration (CI) testing has evolved significantly from its early days of manual code reviews in the 1980s to the automated, cloud-based systems of today. Initially, testing was a slow, manual process focused on finding errors through code inspections. The 1990s saw the rise of unit tests written by specialized testers, but feedback was often delayed due to slow test execution. The cultural shift towards developers writing their own tests was spurred by Extreme Programming in the late 1990s, leading to quicker feedback loops. Automation gained traction in the early 2000s with tools like Jenkins, enabling the first generation of CI tests that automatically verified code changes. By the late 2000s, CI moved to the cloud, allowing smaller teams to benefit from testing services without maintaining their infrastructure. Modern CI practices focus on optimizing test speed through vertical scaling, parallelization, and caching, with cloud providers offering scalable resources. Some high-velocity organizations have begun experimenting with batching and skipping certain tests to enhance speed further. The advent of AI might introduce even faster code review processes by probabilistically predicting outcomes, potentially transforming CI testing once again.
Nov 08, 2025
2,128 words in the original blog post.
In April 2005, Linus Torvalds released the last non-Git version of the Linux kernel and started the transition to a new version control system after facing issues with BitKeeper, the proprietary tool previously used. The reliance on BitKeeper had sparked controversy due to its restrictive licensing, which clashed with the open-source ethos of the Linux community. This led to a conflict when a developer reverse-engineered BitKeeper, prompting Torvalds to seek alternatives. Within weeks, Torvalds created Git, a distributed version control system inspired by BitKeeper's model but designed to be open-source and independent of proprietary constraints. This development marked a significant shift in how software projects managed their source code, eventually leading to Git becoming a globally dominant tool beyond the Linux kernel. The creation of Git exemplified the necessity-driven innovation in technology, catalyzed by practical problems and community-driven evolution, and demonstrated how licensing conflicts can lead to breakthroughs in open-source software development.
Nov 08, 2025
3,392 words in the original blog post.
Graphite has introduced several new features and updates, including the return of PR search via a shortcut for easier navigation, a beta version of the Graphite CLI for early access to new features, and the introduction of upscaled emojis in comments for added emphasis. Additionally, Graphite now supports commit signing to ensure the authenticity of commits by displaying verification of signatures like GPG, SSH, or S/MIME when synced with GitHub. These enhancements were developed in response to user feedback from their Slack community, encouraging further suggestions for improvements. Furthermore, Graphite has announced its participation in the Next.js Conf and highlighted a blog post by Gergely Orosz on the importance of stacked diffs, as well as a case study on how it became the preferred code review tool for engineers at Tecton.
Nov 08, 2025
237 words in the original blog post.
Navigating the realm of version control at a startup, the author reflects on the exceptional developer tools at Facebook, particularly highlighting the benefits of using graphical user interfaces (GUIs) alongside command-line interfaces (CLIs). At Facebook, tools like Interactive Smartlog significantly eased complex Mercurial tasks, demonstrating that GUIs are not just for beginners but also offer substantial advantages for experienced developers by streamlining workflows, reducing errors, and minimizing the need for memorizing commands. Despite a lingering stigma that GUIs are inferior to CLIs, the author argues that GUIs complement CLIs, enhancing productivity and simplifying intricate operations such as interactive rebases. By incorporating GUIs like Graphite’s VS Code extension, developers can efficiently manage their git workflows, visualize commit histories, and handle potentially complex tasks with ease, illustrating that GUIs can be a valuable asset for developers across all experience levels.
Nov 08, 2025
996 words in the original blog post.
GitHub's emergence as a dominant platform for source code hosting and social coding is rooted in its ability to fill the gaps left by predecessors like SourceForge and Google Code. Prior to GitHub's founding in 2008, developers primarily relied on SVN and CVS for version control, with platforms like SourceForge focusing more on software distribution than code collaboration. Git, created by Linus Torvalds in 2004, introduced a distributed version control system that allowed for offline code updates and democratized development, yet it was GitHub that truly capitalized on Git’s potential by integrating social features and making repository hosting seamless. GitHub's founders, Tom Preston-Werner and Chris Wanstrath, identified the need for a platform that combined code hosting with social networking elements, leading to GitHub's rapid adoption and growth in the open-source community. Despite initial resistance from large corporations like Google and Facebook, which developed their own tools, GitHub's user-friendly interface and innovative business model helped it surpass competitors, hosting millions of repositories. The platform's success has been attributed to its ability to specialize in Git hosting while simultaneously fostering a collaborative environment, though its future may see further specialization as the market matures and diversifies into different solutions for open-source and closed-source development needs.
Nov 08, 2025
2,934 words in the original blog post.
Code reviews are essential for maintaining software quality, but inefficiencies in the process can hinder development progress and team morale. The key to effective code reviews lies in balancing speed and accuracy, with practices such as writing concise summaries for pull requests, keeping pull requests small, and stacking related changes to facilitate parallel workstreams. Research indicates that small pull requests, ideally under 200 lines, are reviewed more thoroughly and quickly, reducing post-merge bugs. Effective code review sessions should last around 60 minutes to maintain reviewer focus, with a manageable scope to prevent context switching and bottlenecks. Leveraging tools like Graphite can streamline the review process by automating routine tasks and encouraging best practices, such as maintaining checklists and providing constructive feedback. Tracking metrics like review cycle time and reviewer workloads helps identify workflow constraints, ensuring a predictable and efficient code review cadence. Overall, fostering an environment of open dialogue and continuous learning can transform code reviews into opportunities for team growth and improved software quality.
Nov 08, 2025
3,074 words in the original blog post.
Graphite experienced a significant year in 2023, shipping 11,319 pull requests to enhance infrastructure, fix bugs, and introduce new features, which considerably improved the product. To kick off 2024, Graphite plans to dedicate a week to unveiling major updates and features through daily releases accompanied by blog posts, videos, and a live webinar. The week will culminate with a presentation by CEO Merrill Lutsky, who will explore maximizing Git's potential and address why its workflow has remained largely unchanged despite advances in software and AI, encouraging users to register for the event.
Nov 08, 2025
231 words in the original blog post.
Graphite is addressing the challenge of increasing Continuous Integration (CI) costs faced by rapidly scaling companies by introducing a CI optimizer that integrates with Buildkite and GitHub Actions. This tool is designed to manage CI costs effectively when using stacked pull requests (PRs), a method that accelerates code shipping by enabling smaller and more frequent PRs. Stacking PRs, however, demands constant rebasing, which can unnecessarily trigger full rebuilds in CI systems. The CI optimizer allows selective CI runs on specific parts of a PR stack, such as the bottom or top PRs, and differentiates between fast and slow test suites to prevent excessive CI runs. Additionally, batch merges in the Graphite merge queue further minimize unnecessary CI processes. The CI optimizer, currently in private beta, provides flexible configuration options to ensure efficient CI management, with plans for a public beta rollout soon.
Nov 08, 2025
731 words in the original blog post.
Phabricator, an open-source tool developed by Facebook in 2010 for optimizing internal development workflows, is no longer actively maintained as of June 1, 2021, prompting users to seek alternatives. Known for its integration of code review, repository hosting, bug tracking, and project management, Phabricator facilitated centralized code review workflows and supported large codebases. Users now have various options, such as Graphite, GitLab, GitHub, Azure DevOps, Bitbucket, Gitea, and Gerrit, each catering to different team needs and infrastructure. Graphite, for example, offers fast iteration and collaborative development with features like stacked pull requests, while GitLab provides an integrated environment for the entire DevOps lifecycle. GitHub remains a leading choice for open-source projects, with extensive community support, and Azure DevOps integrates seamlessly with Microsoft's tech stack. Bitbucket excels in environments using the Atlassian toolchain, Gitea offers lightweight self-hosted solutions, and Gerrit focuses on enhancing code review processes. The choice of a Phabricator alternative depends on factors such as team size, integration needs, ease of adoption, feature requirements, and budget, as the right platform can significantly impact engineering productivity and software quality.
Nov 08, 2025
3,075 words in the original blog post.
The Graphite VS Code extension, now available on the VS Code marketplace, enables users to visualize and manage code stacks directly within the IDE, offering features like branch creation, pull request submission, and trunk synchronization, with strong support for stacking. Additionally, the new commit suggested changes feature allows users to apply code suggestions directly from the Graphite web app, enhancing the code review process. The introduction of an unresolved comments panel on the PR page improves comment visibility, a feature developed in response to user feedback from the Slack community. Furthermore, users on the Graphite Team or Enterprise plans can utilize the Graphite Merge Queue for hot-fixing PRs via labels, customizable in repository settings.
Nov 08, 2025
252 words in the original blog post.
In the realm of code reviews, the term "nit" is often used to refer to minor, non-blocking comments or stylistic preferences, but its definition is inconsistent, leading to inefficiencies in the review process. The article critiques the broad application of "nits" in code reviews, arguing that many of these comments, which focus on trivial stylistic issues, could be better addressed through automated tools like linters and style guides. An analysis of 25,000 comments labeled as "nits" revealed that these often fall into categories such as language inconsistencies, code organization, type hints, best practices, and functionality, which can be managed by automated systems. The article advocates for reducing reliance on such comments to increase the efficiency and effectiveness of code reviews, thereby accelerating software development by allowing engineers to focus on substantive discussions rather than on resolving trivial issues. By shifting the focus away from nits, teams can improve the signal-to-noise ratio in code reviews, preserving valuable engineering time for more meaningful feedback and collaboration.
Nov 08, 2025
871 words in the original blog post.