.

Author: codegen-bot

docs/blog/posts.mdx

@@ -6,7 +6,18 @@ iconType: "solid"
 
 <Update
   label="2024-01-24"
-  description="Comparing Codemod Frameworks"
+  description="Static Analysis in the Age of AI Coding Assistants"
+  title="Static Analysis in the Age of AI Coding Assistants"
+>
+## Static Analysis in the Age of AI Coding Assistants
+
+Why traditional language servers aren't enough for the future of AI-powered code manipulation
+
+</Update>
+
+<Update
+  label="2024-01-24"
+  description="A Deep Dive into Codemod Frameworks"
   title="Codemod Frameworks"
 >
 ## Codemod Frameworks
@@ -15,7 +26,7 @@ Comparing popular tools for programmatic code transformation
 
 </Update>
 
-<Update label="2024-01-24" description="Act via Code">
+<Update label="2024-01-24" description="Acting via Code">
 
 ## Act via Code
 

docs/blog/static-analysis-ai.mdx

@@ -0,0 +1,67 @@
+---
+title: "Static Analysis in the Age of AI Coding Assistants"
+description: "Why traditional language servers aren't enough for the future of AI-powered code manipulation"
+icon: "magnifying-glass-chart"
+iconType: "solid"
+---
+
+As AI coding assistants like Cursor, Devin, and others become increasingly sophisticated, a common question emerges: "Why don't these tools leverage more sophisticated static analysis?" The answer reveals an important insight about the future of AI-powered code manipulation.
+
+## The Current Landscape
+
+Today's AI coding assistants typically implement static analysis in a limited way:
+
+- **Context Retrieval**: Tools like Cursor use graph-based queries to fetch relevant code context
+- **Basic Refactoring**: Most rely on VSCode's built-in language server for operations like "rename symbol"
+- **Text-Based Manipulation**: Changes are often made through direct text edits rather than semantic operations
+
+This approach works for simple, single-file changes. However, it breaks down when dealing with large-scale code transformations that require deep understanding of code relationships and dependencies.
+
+## The Challenge of Scale
+
+Why don't AI assistants just use existing language servers? The reality is that traditional language server protocols, while excellent for IDE features, have limitations when it comes to bulk code modifications:
+
+1. **Performance**: Processing large-scale changes through standard language servers is inherently slow
+2. **Scope**: Traditional tools focus on file-level operations, not codebase-wide transformations
+3. **Complexity**: Real-world refactors often require understanding complex relationships between code elements
+
+## The Rise of Codemod Frameworks
+
+Tools like `ts-morph`, `jscodeshift`, and others have emerged to fill this gap, offering more powerful code manipulation capabilities. However, they too have limitations:
+
+- Complex APIs that don't match how developers think about code changes
+- Limited cross-language support
+- Insufficient tooling for managing large-scale transformations
+- Lack of integration with modern AI workflows
+
+## The Future: Agent-Native Language Servers
+
+The next evolution in this space is what we call "agent-native language servers" - tools built specifically for AI agents to manipulate code programmatically. These tools need to:
+
+1. **Express Changes as Code**: Enable AI agents to write programs that perform code transformations, rather than generating text patches
+2. **Provide Rich Static Analysis**: Offer deep understanding of code relationships, dependencies, and impact analysis
+3. **Scale Effectively**: Handle large-scale transformations across massive codebases
+4. **Support the Full Lifecycle**: Address aspects beyond just code changes:
+   - Visualization of change impact
+   - PR management and code ownership
+   - Edge case detection and debugging
+   - Regression monitoring and notification
+
+## Beyond Simple Edits
+
+The future of AI-powered code manipulation isn't just about making text changes - it's about enabling AI agents to:
+
+1. **Build Their Own Tools**: Create and maintain their own transformation utilities
+2. **Understand Impact**: Analyze the full implications of code changes
+3. **Manage Complexity**: Handle cross-file, cross-language transformations
+4. **Ensure Reliability**: Maintain correctness across large-scale changes
+
+## The Path Forward
+
+As companies like Grit.io and Codemod.com demonstrate, there's growing recognition that the future of AI-powered code transformation requires sophisticated static analysis. But more importantly, it requires tools that are built for how AI agents actually work - through code itself.
+
+The most powerful AI coding assistants won't just generate patches or suggest edits. They'll write programs that transform code, leveraging rich static analysis to ensure changes are correct, scalable, and maintainable.
+
+This is why we're building Codegen as a programmatic interface for code manipulation - not just another language server, but a foundation for AI agents to express complex code transformations through code itself.
+
+The future of code manipulation isn't just about better language models - it's about giving those models the right tools to act effectively on code. Just as self-driving cars need sophisticated controls to navigate the physical world, AI coding agents need powerful, precise interfaces to manipulate codebases.

docs/building-with-codegen/commit-and-reset.mdx

@@ -5,14 +5,21 @@ icon: "arrows-rotate"
 iconType: "solid"
 ---
 
-Codegen keeps changes in memory until explicitly written to disk. Two core APIs manage this state:
+Codegen requires you to explicitly commit changes by calling [codebase.commit()](/api-reference/core/Codebase#commit).
 
-- [`Codebase.commit()`](/api-reference/core/Codebase#commit) - Commit changes to disk
-- [`Codebase.reset()`](/api-reference/core/Codebase#reset) - Reset the codebase and filesystem to its initial state
+<Tip>
+  Keeping everything in memory enables fast, large-scale writes. See the [How it
+  Works](/introduction/how-it-works) guide to learn more.
+</Tip>
+
+You can manage your codebase's state with two core APIs:
+
+- [Codebase.commit()](/api-reference/core/Codebase#commit) - Commit changes to disk
+- [Codebase.reset()](/api-reference/core/Codebase#reset) - Reset the `codebase` and filesystem to its initial state
 
 ## Committing Changes
 
-When you make changes to your codebase through Codegen's APIs, they aren't immediately written to disk. You need to explicitly commit them with [`Codebase.commit()`](/api-reference/core/Codebase#commit):
+When you make changes to your codebase through Codegen's APIs, they aren't immediately written to disk. You need to explicitly commit them with [codebase.commit()](/api-reference/core/Codebase#commit):
 
 ```python
 from codegen import Codebase
@@ -31,7 +38,7 @@ This transaction-like behavior helps ensure your changes are atomic and consiste
 
 ## Resetting State
 
-The [`Codebase.reset()`](/api-reference/core/Codebase#reset) method allows you to revert the codebase to its initial state:
+The [codebase.reset()](/api-reference/core/Codebase#reset) method allows you to revert the codebase to its initial state:
 
 ```python
 # Make some changes
@@ -52,6 +59,5 @@ assert codebase.get_file("src/new_file.py", optional=True) is None
 
 <Note>
   `reset()` reverts both the in-memory state and any uncommitted filesystem
-  changes. However, it preserves your codemod implementation in
-  `.codegen/codemods/`.
+  changes. However, it preserves your codemod implementation in `.codegen/`.
 </Note>