Macroscope helps users understand their code through AI-powered code review, automated PR descriptions, and real-time status reports.
Understanding Codebases with AI
Kayvon Beykpour, CEO and founder of Macroscope, shared his journey into software, which began with video games and progressed through building servers, programming, and creating websites, eventually leading to founding multiple companies. Macroscope is his third venture, following a company started in college and Periscope, a live-streaming app acquired by Twitter in 2015. Macroscope was established in late 2023.
The discussion highlighted the significant challenges of managing large codebases, particularly in enterprise projects that can span millions of lines of code. Comprehending these extensive systems and the continuous stream of changes can be a daunting task for individual engineers.
Beykpour explained that Macroscope addresses this problem, drawing from his experience leading product and engineering for Twitter’s consumer team, which once included 1500 engineers. In such a large organization, tracking individual contributions and aligning engineering efforts with strategic priorities proved extremely difficult. Traditional methods like meetings, spreadsheets, and ticketing systems were often inefficient, frequently requiring engineers to be interrupted for status updates.
Macroscope aims to deliver immediate visibility to various leaders—including CEOs, CTOs, and product and engineering managers—who require different levels of detail about ongoing projects. The fundamental principle is that the codebase itself represents the most accurate source of truth for any software company.
The Engineering Behind AI Code Understanding
The development of Macroscope’s AI understanding engine involved a systematic and incremental approach. It started with the capability to summarize individual commits. Macroscope succinctly summarizes each new commit to a connected repository, preserving technical details valuable to stakeholders. This initial functionality proved beneficial for smaller teams seeking to understand codebase modifications.
Building on this foundation, Macroscope introduced a newsfeed feature that tracks the evolution of a repository’s default branch by aggregating and summarizing squash-merged commits. This provides a concise overview of the changes introduced by each merge.
The next advancement involved clustering these precise commit-level summaries to describe product evolution at a higher level, catering to engineering leaders, product stakeholders, or even executives. For example, if a team is working on an onboarding flow, Macroscope can summarize the collective impact of numerous commits over several days, detailing what has changed and what remains to be done.
Technically, Macroscope utilizes advanced language models for inference, but a key innovation lies in its use of the Abstract Syntax Tree (AST) to provide robust context. Instead of simply feeding a code difference (diff) to an LLM for summarization, Macroscope supplies the LLM with a more comprehensive understanding, including information about functions that call the changed code, downstream functions, and example usages. This rich contextual data enables the LLM to generate more coherent and accurate summaries, often exceeding human-written descriptions.
This AST-based methodology is critical for achieving high-signal-to-noise code reviews, distinguishing Macroscope from other tools that can produce overly verbose or irrelevant comments. The objective is to prevent false positives that hinder productivity rather than enhance it.
The AST, an intermediate step in code compilation, implies that Macroscope compiles code and performs static analysis on commits. This process involves creating specialized “code walkers” for various programming languages. The initial Go Walker was developed for Macroscope’s own backend. Subsequently, walkers were built for TypeScript, Python, Swift, Java, Kotlin, and Rust, necessitating the recruitment of language experts proficient in the respective AST packages. This was a time-intensive but crucial undertaking to ensure deep codebase comprehension. Kotlin and Swift were identified as particularly challenging due to less readily available AST libraries.
Addressing codebases that incorporate multiple languages, such as monoliths combining Rust backends with Swift and Kotlin frontends within a single repository, presented architectural complexities. Macroscope has successfully navigated many of these diverse development environments and codebase configurations through its engagements with customers.
Ensuring Reliability and Customization
To enhance the reliability of AI-generated summaries, emphasis is placed on providing the LLM with the most effective and minimal set of useful context, a practice termed “context engineering.” This is coupled with “tasteful prompting,” where the development team, composed of experienced software engineers, meticulously refines prompts to ensure that summaries, pull request descriptions, and code review comments are concise, valuable, and tailored to different audiences (e.g., an individual contributor versus an executive).
Macroscope offers a feature called “Macros,” which allows users to customize prompts and schedule them to run at desired intervals. For instance, weekly release notes can be generated, with prompts adjusted to a specific reading level, incorporating emojis, and focusing on high-level features rather than obscure technical modifications. While the canonical commit summaries are not directly customizable by users, the automation layer facilitates diverse workflows, such as routing summaries to Slack or email, or triggering custom webhooks.
The discussion also explored whether prompt engineering introduces a new form of specialized knowledge or “magic words.” While crafting effective prompts, particularly for summarization, still involves a degree of artistry, these specific “incantations” can vary with different language models (e.g., when transitioning from Sonnet to GPT5). This continuous refinement is essential to meet user experience expectations, as excessively long or verbose outputs are often disregarded.
The Future of AI in Code Review
The motivation behind AI-powered code review stems from the significant amount of time engineers dedicate to this task, often perceiving it as a necessary but cumbersome hurdle. The core idea is that AI tools should be more adept at identifying correctness issues and bugs, doing so faster and with greater accuracy than humans. While human involvement remains vital for cultural aspects, such as mentoring junior engineers and upholding coding conventions, the detection of bugs can be effectively delegated to AI.
The vision for the future includes fewer bugs being deployed, changes being integrated more quickly, and engineers having more time to focus on development. This necessitates an AI review layer that is exceptionally skilled at pinpointing genuine correctness issues and, ideally, providing fixes. Although automated merging of pull requests based on AI checks is not yet widespread, it is considered a transformative objective. Simple modifications, such as text updates, could be merged without human review, leading to substantial time savings.
The proliferation of AI-assisted and autonomous coding agents (like Devons or Code Xs) further underscores the importance of an AI review layer. Macroscope, which initially did not prioritize AI code review, discovered that its AST-crawling methodology produced superior outcomes compared to existing tools, identifying more bugs without generating excessive noise. This realization led to a focused development of the feature and its subsequent successful adoption.
AI-powered code review is seen as a logical progression in the automation of the continuous integration and continuous deployment (CI/CD) pipeline, akin to automated tests and deployments. Skeptics are encouraged to experience a well-implemented AI code review tool, as the efficiency gains often represent a “one-way door” to improved workflows.
Looking forward, in a scenario where autonomous agents contribute significantly more code than human developers, an “air traffic control system” like Macroscope becomes indispensable for understanding codebase changes. This intelligent layer will offer immense leverage. The prevailing optimistic perspective suggests that AI tools will empower engineers to achieve greater feats, allowing them to concentrate on architectural design and complex problem-solving while delegating repetitive tasks, rather than leading to job displacement.
