diff --git a/docs/building-with-codegen/calling-out-to-llms.mdx b/docs/building-with-codegen/calling-out-to-llms.mdx
index 2af46600a..0b2fa7fa3 100644
--- a/docs/building-with-codegen/calling-out-to-llms.mdx
+++ b/docs/building-with-codegen/calling-out-to-llms.mdx
@@ -225,8 +225,7 @@ method.edit(new_impl)
   ```python
   codebase.set_session_options(max_ai_requests=200)
   ```
-<
-Note>
+<Note>
   You can also use `codebase.set_session_options` to increase the execution time and the number of operations allowed in a session. This is useful for handling larger tasks or more complex operations that require additional resources. Adjust the `max_seconds` and `max_transactions` parameters to suit your needs:
   ```python
   codebase.set_session_options(max_seconds=300, max_transactions=500)
diff --git a/docs/building-with-codegen/reducing-conditions.mdx b/docs/building-with-codegen/reducing-conditions.mdx
index e8ad9e739..7460308fa 100644
--- a/docs/building-with-codegen/reducing-conditions.mdx
+++ b/docs/building-with-codegen/reducing-conditions.mdx
@@ -1,5 +1,5 @@
 ---
-title: "Reducing Conditions (Advanced)"
+title: "Reducing Conditions"
 sidebarTitle: "Reducing Conditions"
 icon: "code-branch"
 iconType: "solid"
diff --git a/docs/building-with-codegen/type-annotations.mdx b/docs/building-with-codegen/type-annotations.mdx
new file mode 100644
index 000000000..8cc818e71
--- /dev/null
+++ b/docs/building-with-codegen/type-annotations.mdx
@@ -0,0 +1,177 @@
+---
+title: "Working with Type Annotations"
+sidebarTitle: "Type Annotations"
+icon: "code"
+iconType: "solid"
+---
+
+This guide covers the core APIs and patterns for working with type annotations in Codegen.
+
+## Type Resolution
+
+Codegen builds a complete dependency graph of your codebase, connecting functions, classes, imports, and their relationships. This enables powerful type resolution capabilities:
+
+```python
+from codegen import Codebase
+
+# Initialize codebase with dependency graph
+codebase = Codebase("./")
+
+# Get a function with a type annotation
+function = codebase.get_file("path/to/file.py").get_function("my_func")
+
+# Resolve its return type to actual symbols
+return_type = function.return_type
+resolved_symbols = return_type.resolved_types  # Returns the actual Symbol objects
+
+# For generic types, you can resolve parameters
+if hasattr(return_type, "parameters"):
+    for param in return_type.parameters:
+        resolved_param = param.resolved_types  # Get the actual type parameter symbols
+
+# For assignments, resolve their type
+assignment = codebase.get_file("path/to/file.py").get_assignment("my_var")
+resolved_type = assignment.type.resolved_types
+```
+
+<Tip>
+    Type resolution follows imports and handles complex cases like type aliases, forward references, and generic type parameters.
+</Tip>
+
+## Core Interfaces
+
+Type annotations in Codegen are built on two key interfaces:
+
+- [Typeable](/api-reference/core/Typeable) - The base interface for any node that can have a type annotation (parameters, variables, functions, etc). Provides `.type` and `.is_typed`.
+- [Type](/api-reference/core/Type) - The base class for all type annotations. Provides type resolution and dependency tracking.
+
+Any node that inherits from `Typeable` will have a `.type` property that returns a `Type` object, which can be used to inspect and modify type annotations.
+
+<Tip>Learn more about [inheritable behaviors](/building-with-codegen/inheritable-behaviors) like Typeable here</Tip>
+
+## Core Type APIs
+
+Type annotations can be accessed and modified through several key APIs:
+
+### Function Types
+
+The main APIs for function types are [Function.return_type](/api-reference/python/PyFunction#return-type) and [Function.set_return_type](/api-reference/python/PyFunction#set-return-type):
+
+```python
+# Get return type
+return_type = function.return_type  # -> TypeAnnotation
+print(return_type.source)  # "List[str]"
+print(return_type.is_typed)  # True/False
+
+# Set return type
+function.set_return_type("List[str]")
+function.set_return_type(None)  # Removes type annotation
+```
+
+### Parameter Types
+
+Parameters use [Parameter.type](/api-reference/core/Parameter#type) and [Parameter.set_type_annotation](/api-reference/core/Parameter#set-type-annotation):
+
+```python
+for param in function.parameters:
+    # Get parameter type
+    param_type = param.type  # -> TypeAnnotation
+    print(param_type.source)  # "int"
+    print(param_type.is_typed)  # True/False
+
+    # Set parameter type
+    param.set_type("int")
+    param.set_type(None)  # Removes type annotation
+```
+
+### Variable Types
+
+Variables and attributes use [Assignment.type](/api-reference/core/Assignment#type) and [Assignment.set_type_annotation](/api-reference/core/Assignment#set-type-annotation). This applies to:
+- Global variables
+- Local variables
+- Class attributes (via [Class.attributes](/api-reference/core/Class#attributes))
+
+```python
+# For global/local assignments
+assignment = file.get_assignment("my_var")
+var_type = assignment.type  # -> TypeAnnotation
+print(var_type.source)  # "str"
+
+# Set variable type
+assignment.set_type("str")
+assignment.set_type(None)  # Removes type annotation
+
+# For class attributes
+class_def = file.get_class("MyClass")
+for attr in class_def.attributes:
+    # Each attribute has an assignment property
+    attr_type = attr.assignment.type  # -> TypeAnnotation
+    print(f"{attr.name}: {attr_type.source}")  # e.g. "x: int"
+    
+    # Set attribute type
+    attr.assignment.set_type("int")
+
+# You can also access attributes directly by index
+first_attr = class_def.attributes[0]
+first_attr.assignment.set_type("str")
+```
+
+## Working with Complex Types
+
+### Union Types
+
+Union types ([UnionType](/api-reference/core/UnionType)) can be manipulated as collections:
+
+```python
+# Get union type
+union_type = function.return_type  # -> A | B 
+print(union_type.symbols)  # ["A", "B"]
+
+# Add/remove options
+union_type.append("float")
+union_type.remove("None")
+
+# Check contents
+if "str" in union_type.options:
+    print("String is a possible type")
+```
+<Tip>Learn more about [working with collections here](/building-with-codegen/collections)</Tip>
+
+### Generic Types
+
+Generic types ([GenericType](/api-reference/core/GenericType)) expose their parameters as collection of [Parameters](/api-reference/core/Parameter):
+
+```python
+# Get generic type
+generic_type = function.return_type  # -> GenericType
+print(generic_type.base)  # "List"
+print(generic_type.parameters)  # ["str"]
+
+# Modify parameters
+generic_type.parameters.append("int")
+generic_type.parameters[0] = "float"
+
+# Create new generic
+function.set_return_type("List[str]")
+```
+<Tip>Learn more about [working with collections here](/building-with-codegen/collections)</Tip>
+
+### Type Resolution
+
+Type resolution uses [`Type.resolved_value`](/api-reference/core/Type#resolved-value) to get the actual symbols that a type refers to:
+
+```python
+# Get the actual symbols for a type
+type_annotation = function.return_type  # -> Type
+resolved_types = type_annotation.resolved_value  # Returns an Expression, likely a Symbol or collection of Symbols
+
+# For generic types, resolve each parameter
+if hasattr(type_annotation, "parameters"):
+    for param in type_annotation.parameters:
+        param_types = param.resolved_value # Get symbols for each parameter
+
+# For union types, resolve each option
+if hasattr(type_annotation, "options"):
+    for option in type_annotation.options:
+        option_types = option.resolved_value # Get symbols for each union option
+```
diff --git a/docs/introduction/faq.mdx b/docs/introduction/faq.mdx
index 7f4f9eeb6..d7f3abfba 100644
--- a/docs/introduction/faq.mdx
+++ b/docs/introduction/faq.mdx
@@ -20,6 +20,9 @@ iconType: "solid"
       Interested in adding support for your language? [Let us know](https://x.com/codegen) or [contribute](/introduction/community)!
     </Note>
 
+  </Accordion>
+    <Accordion title="Is Codegen exact?" icon="scale-balanced">
+    Pretty much! Codegen is roughly on par with `mypy` and `tsc`. There are always edge cases in static analysis that are provably impossible to get (for example doing `eval()` on a string), but all of Codegen's APIs are intended to be exact unless otherwise specified. Please reach out if you find an edge case and we will do our best to patch it.
   </Accordion>
   <Accordion title="Is Codegen suitable for large codebases?" icon="database">
     Yes! Codegen was developed on multmillion-line Python and Typescript codebases
diff --git a/docs/introduction/overview.mdx b/docs/introduction/overview.mdx
index 1dab4925d..b5cfbef03 100644
--- a/docs/introduction/overview.mdx
+++ b/docs/introduction/overview.mdx
@@ -9,9 +9,11 @@ iconType: "solid"
 
 It provides a scriptable interface to a powerful, multi-lingual language server built on top of [Tree-sitter](https://tree-sitter.github.io/tree-sitter/).
 
-export const metaCode = `# Codegen builds a complete graph connecting
-#  functions, classes, imports and their relationships
-from codegen import Codebase
+export const metaCode = `from codegen import Codebase
+
+# Codegen builds a complete graph connecting
+# functions, classes, imports and their relationships
+codebase = Codebase("./")
 
 # Work with code without dealing with syntax trees or parsing
 for function in codebase.functions:
@@ -33,7 +35,7 @@ def baz():
 
 <iframe
   width="100%"
-  height="300px"
+  height="320px"
   scrolling="no"
   src={`https://chadcode.sh/embedded/codemod/?code=${encodeURIComponent(
     metaCode
diff --git a/docs/mint.json b/docs/mint.json
index b80ab355f..a0c1e2d2f 100644
--- a/docs/mint.json
+++ b/docs/mint.json
@@ -111,6 +111,7 @@
 				"building-with-codegen/local-variables",
 				"building-with-codegen/comments-and-docstrings",
 				"building-with-codegen/external-modules",
+				"building-with-codegen/type-annotations",
 				"building-with-codegen/moving-symbols",
 				"building-with-codegen/collections",
 				"building-with-codegen/traversing-the-call-graph",
diff --git a/docs/tutorials/deleting-dead-code.mdx b/docs/tutorials/deleting-dead-code.mdx
index 7028681c1..655108f59 100644
--- a/docs/tutorials/deleting-dead-code.mdx
+++ b/docs/tutorials/deleting-dead-code.mdx
@@ -18,7 +18,7 @@ This guide will show you how to safely identify and remove genuinely unused code
 
 ## Overview
 
-To simply identify code without any external usages, you can check for the absence of [`Symbol.usages`](/api-reference/core/Symbol#usages).
+To simply identify code without any external usages, you can check for the absence of [Symbol.usages](/api-reference/core/Symbol#usages).
 
 <Tip>See [Dependencies and Usages](/building-with-codegen/dependencies-and-usages) for more information on how to use these properties.</Tip>
 
@@ -28,6 +28,9 @@ for function in codebase.functions:
     # Remove functions with no usages
     if not function.usages:
         function.remove()
+
+# Commit
+codebase.commit()
 ```
 
 <Warning>
@@ -36,7 +39,7 @@ This will remove all code that is not explicitly referenced elsewhere, including
 
 ## Filtering for Special Cases
 
-To filter out special cases that are not explicitly referenced yet are, nonetheless, worth keeping around, you can use the following:
+To filter out special cases that are not explicitly referenced yet are, nonetheless, worth keeping around, you can use the following pattern:
 
 
 ```python
@@ -63,107 +66,16 @@ for function in codebase.functions:
         print(f"Removing unused function: {function.name}")
         # Remove the function from the file
         function.remove()
-```
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
-
-
-
-
-
-
-## Eliminating Dead Imports
-
-To remove unused imports, you can check if the imported symbol has any usages:
-
-<CodeGroup>
-```python python
-for import_stmt in codebase.imports:
-    # Check if the import statement has no usages
-    if not import_stmt.usages:
-        # Print a message indicating the removal of the unused import
-        print(f"Removing unused import: {import_stmt.name}")
-        # Remove the import statement from the file
-        import_stmt.remove()
-```
-
-```python typescript
-for import_stmt in codebase.imports:
-    # Check if the import statement has no usages
-    if not import_stmt.usages:
-        # Print a message indicating the removal of the unused import
-        print(f"Removing unused import: {import_stmt.name}")
-        # Remove the import statement from the file
-        import_stmt.remove()
+# Commit
+codebase.commit()
 ```
-</CodeGroup>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
 
 ## Cleaning Up Unused Variables
 
 To remove unused variables, you can check for their usages within their scope:
 
-<CodeGroup>
-```python python
-for func in codebase.functions:
-    # Iterate through local variable assignments in the function
-    for var_assignments in func.code_block.local_var_assignments:
-        # Check if the local variable assignment has no usages
-        if not var_assignments.local_usages:
-            # Remove the local variable assignment
-            var_assignments.remove()
-```
-
 ```python typescript
 for func in codebase.functions:
     # Iterate through local variable assignments in the function
@@ -172,125 +84,17 @@ for func in codebase.functions:
         if not var_assignments.local_usages:
             # Remove the local variable assignment
             var_assignments.remove()
-```
-</CodeGroup>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
-
-
-
-
-
-
-## Ignoring False Positives
-
-Every codebase is different, and usually there's a (small) set of things that could look like dead code but aren't.
-
-Simply tell the assistant to avoid certain cases (like files starting with `test_`, or children of a specific class).
-
-## Removing Dead Classes
-
-To remove unused classes, check for the absence of usages:
-
-<CodeGroup>
-```python python
-for cls in codebase.classes:
-    # Check if the class has no usages
-    if not cls.usages:
-        # Print a message indicating the removal of the unused class
-        print(f"Removing unused class: {cls.name}")
-        # Remove the class from the file
-        cls.remove()
-```
-
-```python typescript
-for cls in codebase.classes:
-    # Check if the class has no usages
-    if not cls.usages:
-        # Print a message indicating the removal of the unused class
-        print(f"Removing unused class: {cls.name}")
-        # Remove the class from the file
-        cls.remove()
+# Commit
+codebase.commit()
 ```
-</CodeGroup>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
 
 ## Cleaning Up After Removal
 
 After removing dead code, you may need to clean up any remaining artifacts:
 
-<CodeGroup>
-```python python
-for file in codebase.files:
-    # Check if the file is empty
-    if not file.content.strip():
-        # Print a message indicating the removal of the empty file
-        print(f"Removing empty file: {file.filepath}")
-        # Remove the empty file
-        file.remove()
-
-# commit is NECESSARY to remove the files from the codebase
-codebase.commit()
-
-# Remove redundant newlines
-for file in codebase.files:
-    # Replace three or more consecutive newlines with two newlines
-    file.edit(re.sub(r"\n{3,}", "\n\n", file.content))
-```
-
-```python typescript
+```python
 for file in codebase.files:
     # Check if the file is empty
     if not file.content.strip():
@@ -307,48 +111,3 @@ for file in codebase.files:
     # Replace three or more consecutive newlines with two newlines
     file.edit(re.sub(r"\n{3,}", "\n\n", file.content))
 ```
-</CodeGroup>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-## Best Practices
-
-1. **Use Caution**: Always double-check before removing code, especially for elements that might be used dynamically or in hard-to-detect ways.
-
-2. **Incremental Removal**: Remove dead code in stages, committing and testing after each stage to ensure you haven't broken anything.
-
-3. **Consider Visibility**: Be extra cautious when removing public APIs or elements that might be used by external code.
-
-4. **Update Documentation**: After removing dead code, update any related documentation or comments to maintain consistency.
-
-5. **Use Version Control**: Always perform these operations in a version-controlled environment, so you can easily revert changes if needed.
-
-By following these guidelines, you can effectively clean up your codebase by removing dead code while maintaining its integrity and functionality.
\ No newline at end of file
diff --git a/docs/tutorials/increase-type-coverage.mdx b/docs/tutorials/increase-type-coverage.mdx
index 52d833b14..5c8579971 100644
--- a/docs/tutorials/increase-type-coverage.mdx
+++ b/docs/tutorials/increase-type-coverage.mdx
@@ -13,64 +13,85 @@ Common use cases include:
 - Checking if a generic type has a given subtype
 - Resolving a type annotation
 
-## Finding the extent of your type coverage
+<Tip>
+    Adding type hints can improve developer experience and [significantly speed up](https://github.com/microsoft/Typescript/wiki/Performance#using-type-annotations) programs like the Typescript compiler and `mypy`.
+</Tip>
 
-First, to get an indication of your progress on type coverage, count the number of function arguments that have type hints in your codebase:
+<Note>See [Type Annotations](/building-with-codegen/type-annotations) for a general overview of the type maninpulation</Note>
 
-<CodeGroup>
-```python python
-total_parameters = 0
-typed_parameters = 0
+## APIs for monitoring types
 
-# Iterate through all functions in the file
-for function in codebase.functions:
-    # Count the total number of parameters
-    total_parameters += len(function.parameters)
-    # Count the number of parameters that have type hints
-    typed_parameters += sum(1 for param in function.parameters if param.is_typed)
+Codegen programs typically access type annotations through the following APIs:
+- [Parameter.type](/api-reference/core/Parameter#type)
+- [Function.return_type](/api-reference/python/PyFunction#return-type)
+- [Assignment.type](/api-reference/core/Assignment#type)
 
-# Calculate the percentage of parameters with type hints
-if total_parameters > 0:
-    percentage_typed = (typed_parameters / total_parameters) * 100
-else:
-    percentage_typed = 0
+Each of these has an associated setter.
 
-# Print the result
-print(f"Percentage of function arguments with type hints: {percentage_typed:.2f}%")
-```
 
-```python typescript
+## Finding the extent of your type coverage
+
+T to get an indication of your progress on type coverage, analyze the percentage of typed elements across your codebase
+
+```python
+# Initialize counters for parameters
 total_parameters = 0
 typed_parameters = 0
 
-# Iterate through all functions in the file
+# Initialize counters for return types
+total_functions = 0
+typed_returns = 0
+
+# Initialize counters for class attributes
+total_attributes = 0
+typed_attributes = 0
+
+# Count parameter and return type coverage
 for function in codebase.functions:
-    # Count the total number of parameters
+    # Count parameters
     total_parameters += len(function.parameters)
-    # Count the number of parameters that have type hints
     typed_parameters += sum(1 for param in function.parameters if param.is_typed)
 
-# Calculate the percentage of parameters with type hints
-if total_parameters > 0:
-    percentage_typed = (typed_parameters / total_parameters) * 100
-else:
-    percentage_typed = 0
-
-# Print the result
-print(f"Percentage of function arguments with type hints: {percentage_typed:.2f}%")
+    # Count return types
+    total_functions += 1
+    if function.return_type and function.return_type.is_typed:
+        typed_returns += 1
+
+# Count class attribute coverage
+for cls in codebase.classes:
+    for attr in cls.attributes:
+        total_attributes += 1
+        if attr.is_typed:
+            typed_attributes += 1
+
+# Calculate percentages
+param_percentage = (typed_parameters / total_parameters * 100) if total_parameters > 0 else 0
+return_percentage = (typed_returns / total_functions * 100) if total_functions > 0 else 0
+attr_percentage = (typed_attributes / total_attributes * 100) if total_attributes > 0 else 0
+
+# Print results
+print("\nType Coverage Analysis")
+print("---------------------")
+print(f"Parameters: {param_percentage:.1f}% ({typed_parameters}/{total_parameters} typed)")
+print(f"Return types: {return_percentage:.1f}% ({typed_returns}/{total_functions} typed)")
+print(f"Class attributes: {attr_percentage:.1f}% ({typed_attributes}/{total_attributes} typed)")
 ```
-</CodeGroup>
-
 
+This analysis gives you a breakdown of type coverage across three key areas:
+1. Function parameters - Arguments passed to functions
+2. Return types - Function return type annotations
+3. Class attributes - Type hints on class variables
 
-You can perform an analogous operation for return types, method parameters, and more. Note that the code presented here only analyzes non-method functions.
+<Tip>
+    Focus first on adding types to the most frequently used functions and classes, as these will have the biggest impact on type checking and IDE support.
+</Tip>
 
 ## Adding simple return type annotations
 
 To add a return type, use `function.set_return_type`. The script below will add a `-> None` return type to all functions that contain no return statements:
 
 <CodeGroup>
-```python python
+```python For Python
 for file in codebase.files:
     # Check if 'app' is in the file's filepath
     if "app" in file.filepath:
@@ -82,7 +103,7 @@ for file in codebase.files:
                 function.set_return_type("None")
 ```
 
-```python typescript
+```python For Typescript
 for file in codebase.files:
     # Check if 'app' is in the file's filepath
     if "app" in file.filepath:
@@ -96,136 +117,6 @@ for file in codebase.files:
 </CodeGroup>
 
 
-## Adding a type to a union type
-
-Since a union type is a collection, you can call standard methods such as append to add new types to it.
-
-<CodeGroup>
-```python python
-target_file = codebase.get_file("path/to/file.py")
-function = target_file.get_function("function_name")
-# def function_name() -> a | b: ...
-
-# import c from module
-c = codebase.get_file("path/to/module.py").get_symbol("c")
-target_file.add_symbol_import(c)
-
-# Add a new option to the return type
-function.return_type.append("c")
-```
-
-```python typescript
-target_file = codebase.get_file("path/to/file.ts")
-function = target_file.get_function("functionName")
-# function functionName(): a | b: ...
-c = codebase.get_file("path/to/module.ts").get_symbol("c")
-target_file.add_symbol_import(c)
-
-# Add a new option to the return type
-function.return_type.append("c")
-```
-</CodeGroup>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-## Adding a type to a generic type
-
-You can add parameters to a generic type in a similar fashion
-
-```python
-function = codebase.get_file("path/to/file.py").get_function("function_name")
-# def function_name() -> tuple[a, b]: ...
-
-# Add a new parameter to the return type
-function.return_type.parameters.append("float")
-```
-
-## Checking if a generic type contains a given type
-
-You can also check if a given type is in the list of parameters
-
-
-```python
-function = codebase.get_file("path/to/file.py").get_function("function_name")
-# def function_name() -> tuple[a, b]: ...
-
-# Check if "a" is in the function's return_type's parameters
-if "a" in function.return_type.parameters:
-    # type "a" is present in the return type parameters
-    print("type 'a' is present in the return type parameters.")
-```
-## Resolving a type_annotation
-
-You can find the referenced symbol of any type
-
-<CodeGroup>
-```python python
-function = codebase.get_file("path/to/file.py").get_function("function_name")
-# from xyz import MyContainer, a, b
-# def function_name() -> MyContainer[a, b]: ...
-print(function.return_type.resolved_types)  # Resolves to MyContainer
-for parameter in function.return_type.parameters:
-    print(parameter.resolved_types)  # Resolves to a and b
-```
-
-```python typescript
-function = codebase.get_file("path/to/file.ts").get_function("functionName")
-# import { MyContainer, a, b } './types'
-# function function_name(): MyContainer<a, b> { ... }
-print(function.return_type.resolved_types)  # Resolves to MyContainer
-for parameter in function.return_type.parameters:
-    print(parameter.resolved_types)  # Resolves to a and b
-```
-</CodeGroup>
-
-
+## Coming Soon: Advanced Type Inference
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-## Resolving a type_annotation of an assignment
-You can also use resolved_type directly on assignments to get the resolved_symbol
-
-```python
-a = codebase.get_file("path/to/file.py").get_global_var("a")
-# a: MyType = ...
-print(a.type)  # Resolves to MyType
-a.type.rename("MyNewType")  # Renames the symbol `MyType` to `MyNewType` throughout the codebase
-```
+<Warning>Codegen is building out an API for direct interface with `tsc` and `mypy` for precise type inference. Interested piloting this API? Let us know!</Warning>
\ No newline at end of file
diff --git a/docs/tutorials/manage-feature-flags.mdx b/docs/tutorials/manage-feature-flags.mdx
index 117b65007..41ac176a0 100644
--- a/docs/tutorials/manage-feature-flags.mdx
+++ b/docs/tutorials/manage-feature-flags.mdx
@@ -5,73 +5,30 @@ icon: "flag"
 iconType: "solid"
 ---
 
-Codegen SDK provides powerful APIs for managing feature flag usage in code. This guide will walk you through the basics of how to detect and clean up obsolete feature flags.
+Codegen has been used in production for multi-million line codebases to automatically delete "dead" (rolled-out) feature flags. This guide will walk you through analyzing feature flag usage and safely removing rolled out flags.
 
+<Warning>
+    Every codebase does feature flags differently. This guide shows common techniques and syntax but likely requires adaptation to codebase-specific circumstances.
+</Warning>
 
-## Removing rolled out flags
+## Analyzing Feature Flag Usage
 
-Once a feature has been fully rolled out behind a flag and is stable on production, the next step is to remove old fallback code paths.
+Before removing a feature flag, it's important to analyze its usage across the codebase. Codegen provides tools to help identify where and how feature flags are used.
 
-Common syntax for feature flags include:
+### For Python Codebases
 
-<AccordionGroup defaultExpanded={true}>
-    <Accordion title="Typsecript">
-    ```python
-feature_flag = codebase.get_symbol("ROLLED_OUT_FLAG_TO_DELETE")
-feature_flag_name = feature_flag.name
-
-# Iterate over all usages of the feature flag import
-for usage_symbol in feature_flag.get_all_symbol_usages():
-    if isinstance(usage_symbol, Function):
-        # Check statements within the function
-        for statement in usage_symbol.code_block.get_statements():
-            if isinstance(statement, IfBlockStatement) and feature_flag_name in statement.condition.source:
-                # Simplify the condition of the if statement
-                statement.reduce_condition(bool_condition=feature_flag_name == statement.condition.source)
-    elif isinstance(usage_symbol, Import):
-        # Remove the import of the feature flag
-        usage_symbol.remove()
-      ```
-  </Accordion>
-
-  <Accordion title="Python">
-      ```python
-flag_name = "CODEMOD_RUN_SYNTAX_PREHIGHLIGHT"
-
-# Get the feature flag variable
-feature_flag_file = codebase.get_file("codegen-backend/app/utils/posthog/feature_flags.py")
-flag_class = feature_flag_file.get_class("FeatureFlag")
-
-# Check if the flag_var is None before proceeding
-flag_var = flag_class.get_attribute(flag_name)
-if not flag_var:
-    raise Exception(f'No such flag: {flag_name}')
-
-# Remove the feature flag from the class
-flag_var.remove()
-
-# Remove all usages of the feature flag
-for usage in flag_var.usages():
-    # If the usage is in an if statement, remove the entire if statement
-    if isinstance(usage.parent, IfBlockStatement):
-        usage.parent.remove()
-    # If the usage is in a with statement, unwrap the with statement
-    elif isinstance(usage.parent, WithStatement):
-        usage.parent.code_block.unwrap()
-    # Otherwise, just remove the usage
-    else:
-        usage.remove()
-      ```
-  </Accordion>
-</AccordionGroup>
+For Python codebases using a `FeatureFlags` class pattern like so:
+```python
+class FeatureFlags:
+    FEATURE_1 = False
+    FEATURE_2 = True
+```
 
+You can use [Class.get_attribute(...)](/api-reference/core/Class#get-attribute) and [Attribute.usages](/api-reference/core/Attribute#usages) to analyze the coverage of your flags, like so:
 
-## Deleting unused feature flags
 
-Detecting unused feature flag is a specific use case of [deleting dead code](/tutorials/deleting-dead-code), isolated to a specific search space.
-```python Delete unused flag
-print = codebase.log
 
+```python
 feature_flag_usage = {}
 feature_flag_class = codebase.get_class('FeatureFlag')
 
@@ -79,9 +36,9 @@ if feature_flag_class:
     # Initialize usage count for all attributes
     for attr in feature_flag_class.attributes:
         feature_flag_usage[attr.name] = 0
-
+    
     # Get all usages of the FeatureFlag class
-    for usage in feature_flag_class.usages():
+    for usage in feature_flag_class.usages:
         usage_source = usage.usage_symbol.source if hasattr(usage, 'usage_symbol') else str(usage)
         for flag_name in feature_flag_usage.keys():
             if f"FeatureFlag.{flag_name}" in usage_source:
@@ -101,17 +58,100 @@ else:
     print("❗ FeatureFlag enum not found in the codebase")
 ```
 
+This will output a table showing all feature flags and their usage counts, helping identify which flags are candidates for removal.
+
+<Tip>
+    Learn more about [Attributes](/building-with-codegen/class-api#class-attributes) and [tracking usages](/building-with-codegen/dependencies-and-usages) here
+</Tip>
+
+
+## Removing Rolled Out Flags
 
-#### Recommended Next Steps
-Once rolled out feature flags are removed, new dead code paths may have been created. Run a delete dead code codemod to ensure complete clean-up.
+Once you've identified a flag that's ready to be removed, Codegen can help safely delete it and its associated code paths.
 
+<Tip>
+    This primarily leverages Codegen's API for [reduction conditions](/building-with-codegen/reducing-conditions)
+</Tip>
 
-## Best Practices
-1. **Use Caution**: Ensure that flags have been fully rolled out before deleting.
+### Python Example
+
+For Python codebases, here's how to remove a feature flag and its usages:
+
+```python
+flag_name = "FEATURE_TO_REMOVE"
+
+# Get the feature flag variable
+feature_flag_file = codebase.get_file("app/utils/feature_flags.py")
+flag_class = feature_flag_file.get_class("FeatureFlag")
+
+# Check if the flag exists
+flag_var = flag_class.get_attribute(flag_name)
+if not flag_var:
+    print(f'No such flag: {flag_name}')
+    return
+
+# Remove all usages of the feature flag
+for usage in flag_var.usages:
+    if isinstance(usage.parent, IfBlockStatement):
+        # For if statements, reduce the condition to True
+        usage.parent.reduce_condition(True)
+    elif isinstance(usage.parent, WithStatement):
+        # For with statements, keep the code block
+        usage.parent.code_block.unwrap()
+    else:
+        # For other cases, remove the usage
+        usage.remove()
+
+# Remove the flag definition
+flag_var.remove()
+
+# Commit changes
+codebase.commit()
+```
+
+### React/TypeScript Example
+
+For React applications using a hooks-based feature flag system:
+
+```python
+feature_flag_name = "NEW_UI_ENABLED"
+target_value = True  # The value to reduce the flag to
+
+print(f'Removing feature flag: {feature_flag_name}')
+
+# 1. Remove from configuration
+config_file = codebase.get_file("src/featureFlags/config.ts")
+feature_flag_config = config_file.get_symbol("FEATURE_FLAG_CONFIG").value
+if feature_flag_name in feature_flag_config.keys():
+    feature_flag_config.pop(feature_flag_name)
+    print('✅ Removed from feature flag config')
+
+# 2. Find and reduce all hook usages
+hook = codebase.get_function("useFeatureFlag")
+for usage in hook.usages:
+    fcall = usage.match
+    if isinstance(fcall, FunctionCall):
+        # Check if this usage is for our target flag
+        first_arg = fcall.args[0].value
+        if isinstance(first_arg, String) and first_arg.content == feature_flag_name:
+            print(f'Reducing in: {fcall.parent_symbol.name}')
+            # This automatically handles:
+            # - Ternary expressions: flag ? <New /> : <Old />
+            # - If statements: if (flag) { ... }
+            # - Conditional rendering: {flag && <Component />}
+            fcall.reduce_condition(target_value)
+
+# 3. Commit changes
+codebase.commit()
+```
 
-2. **Fix Tests**: Check for additional ways feature flags are used in the codebase (e.g. string arguments in test patches).
+This will:
+1. Remove the feature flag from the configuration
+2. Find all usages of the `useFeatureFlag` hook for this flag
+3. Automatically reduce any conditional logic using the flag
+4. Handle common React patterns like ternaries and conditional rendering
 
 
-### Related Examples
-- [reduce if statements](/building-with-codegen/reducing-conditions)
-- [unwrap with statements](/building-with-codegen/statements-and-code-blocks#wrapping-and-unwrapping-statements)
\ No newline at end of file
+## Related Resources
+- [Reducing Conditions](/building-with-codegen/reducing-conditions) - Details on condition reduction APIs
+- [Dead Code Removal](/tutorials/deleting-dead-code) - Remove unused code after flag deletion
\ No newline at end of file
diff --git a/docs/tutorials/python2-to-python3.mdx b/docs/tutorials/python2-to-python3.mdx
index 60a448768..040f38776 100644
--- a/docs/tutorials/python2-to-python3.mdx
+++ b/docs/tutorials/python2-to-python3.mdx
@@ -8,7 +8,9 @@ iconType: "solid"
 
 Migrating from Python 2 to Python 3 involves several syntax and API changes. This guide will walk you through using Codegen to automate this migration, handling print statements, string handling, iterators, and more.
 
+<Info>
 You can find the complete example code in our [examples repository](https://github.com/codegen-sh/codegen-examples/tree/main/python2_to_python3).
+</Info>
 
 ## Overview
 
diff --git a/docs/tutorials/sqlalchemy-1.6-to-2.0.mdx b/docs/tutorials/sqlalchemy-1.6-to-2.0.mdx
index d562c5544..654a5bbab 100644
--- a/docs/tutorials/sqlalchemy-1.6-to-2.0.mdx
+++ b/docs/tutorials/sqlalchemy-1.6-to-2.0.mdx
@@ -8,7 +8,9 @@ iconType: "solid"
 
 Migrating from [SQLAlchemy](https://www.sqlalchemy.org/) 1.6 to 2.0 involves several API changes to support the new 2.0-style query interface. This guide will walk you through using Codegen to automate this migration, handling query syntax, session usage, and ORM patterns.
 
-You can find the complete example code in our [examples repository](https://github.com/codegen-sh/codegen-examples/tree/main/sqlalchemy_1.6_to_2.0).
+<Info>
+You can find the complete example code in our [examples repository](https://github.com/codegen-sh/codegen-examples/tree/main/examples/sqlalchemy_1.6_to_2.0).
+</Info>
 
 ## Overview
 
diff --git a/docs/tutorials/training-data.mdx b/docs/tutorials/training-data.mdx
index 6cd9c72d1..e6013ecdc 100644
--- a/docs/tutorials/training-data.mdx
+++ b/docs/tutorials/training-data.mdx
@@ -1,6 +1,6 @@
 ---
-title: "Generating Training Data for LLMs"
-sidebarTitle: "Training Data"
+title: "Mining Training Data for LLMs"
+sidebarTitle: "Mining Data"
 description: "Learn how to generate training data for large language models using Codegen"
 icon: "network-wired"
 iconType: "solid"
@@ -8,7 +8,7 @@ iconType: "solid"
 
 This guide demonstrates how to use Codegen to generate high-quality training data for large language models (LLMs) by extracting function implementations along with their dependencies and usages. This approach is similar to [word2vec](https://www.tensorflow.org/text/tutorials/word2vec) or [node2vec](https://snap.stanford.edu/node2vec/) - given the context of a function, learn to predict the function's implementation.
 
-<Info>View the full code in our [examples repository](https://github.com/codegen-sh/codegen-examples/blob/main/generate_training_data/run.py)</Info>
+<Info>View the full code in our [examples repository](https://github.com/codegen-sh/codegen-examples/blob/main/examples/generate_training_data/run.py)</Info>
 
 <Tip>This example works with both Python and Typescript repositories without modification</Tip>
 
diff --git a/docs/tutorials/unittest-to-pytest.mdx b/docs/tutorials/unittest-to-pytest.mdx
index 345c41423..5e57957ba 100644
--- a/docs/tutorials/unittest-to-pytest.mdx
+++ b/docs/tutorials/unittest-to-pytest.mdx
@@ -8,7 +8,9 @@ iconType: "solid"
 
 Migrating from [unittest](https://docs.python.org/3/library/unittest.html) to [pytest](https://docs.pytest.org/) involves converting test classes and assertions to pytest's more modern and concise style. This guide will walk you through using Codegen to automate this migration.
 
-You can find the complete example code in our [examples repository](https://github.com/codegen-sh/codegen-examples/tree/main/unittest_to_pytest).
+<Info>
+You can find the complete example code in our [examples repository](https://github.com/codegen-sh/codegen-examples/tree/main/examples/unittest_to_pytest).
+</Info>
 
 ## Overview