# To the moon! Navigating deep context in legacy code with Augment Agent

Forrest Brazeal · Matt Ball

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/6NIr_cYPglk-moon-navigating-deep-context-in-legacy-code) · [Video](https://www.youtube.com/watch?v=6NIr_cYPglk)

## To the moon! Navigating deep context in legacy code with Augment Agent

An Apollo guidance demo moves from explaining descent alarms to generating Python guidance code, showing how repository context and fixed tests support legacy modernization.

Basic familiarity with Python modules, automated tests, and command-line errors is helpful; no assembly experience is required.

### How do you understand code you cannot comfortably read?

[0:16](https://www.youtube.com/watch?v=6NIr_cYPglk&t=16s)

How do you get useful work done in a legacy codebase when its language, conventions, and design are unfamiliar? Before changing anything, you need to recover the reasoning embedded in it. Forrest Brazeal and Matt Ball approach that problem with an unusually demanding example: the Apollo 11 guidance computer. Their demonstration moves from understanding assembly code to implementing part of its behavior in Python with [Augment Code](https://www.augmentcode.com/).

Brazeal introduces himself as an Augment friend and partner, not an employee; Ball describes his role as an Augment solutions architect. The exercise is to investigate the historical code, then use an agent to complete a simulated lunar landing. The session also offers a free trial, though the interface and access terms shown belong to the recording.

![A “Today’s mission” slide pairs an astronaut photograph with five agenda items: Augment Agent, AI Agent Best Practices, The Apollo 11 Guidance Computer, Navigating the (legacy) code, and To the moon!](https://ai.engineer/api/talk-essay-media/972296d848f70956375bfd272cd8a4ed6a333f7146a430345faa3a033558b6a9)

Today’s mission connects Augment Agent, the Apollo 11 guidance computer, and navigating legacy code.

### Retrieve code knowledge, then choose how to act

[1:37](https://www.youtube.com/watch?v=6NIr_cYPglk&t=97s)

Ball starts with the input to the model: **useful answers require relevant code context**. A repository is not simply a collection of prose documents. Understanding a routine can require locating its callers, data structures, conventions, and related behavior. He describes Augment’s proprietary context engine as a system for retrieving the right repository knowledge and passing it to models, attributing better understanding and output quality to that retrieval. Those are product claims, not comparative measurements from this demonstration.

The surrounding product choices address enterprise adoption. Plugins let developers remain in existing IDEs—for example, IntelliJ for an older Java project. Ball also highlights customer-managed encryption keys and ISO/IEC 42001. The latter concerns an AI management system; it does not certify the correctness of generated code.

The execution mode determines what happens after the system retrieves context:

| Mode | Best fit | Execution pattern |
|---|---|---|
| Chat | Explore code and ask technical questions | One turn at a time, with user control |
| Agent | Complete larger tasks using tools | Read files, issue commands, and act on results |
| Remote agent | Continue work away from the laptop | Run in the cloud, including parallel tasks |

Remote execution matters when a task should keep running after the developer closes the laptop. It also makes independent tasks candidates for concurrent work.

![Three numbered columns describe chat for exploring code and technical questions, an agent for workflow tasks, and a remote agent for completing tasks from the cloud.](https://ai.engineer/api/talk-essay-media/31ec64f9aba2f3a36e28480b8d4c1d929e64629b210e66424faa67740b473f35)

Mission Tools compares Augment Code Chat, Augment Agent, and Remote Agent.

Brazeal connects that possibility to an earlier workshop contest: someone wondered how the winners submitted solutions so quickly across several problems. He suggests that remote agents might have helped them work in parallel, but does not establish that this is what happened.

### An unfamiliar language with consequential behavior

[3:40](https://www.youtube.com/watch?v=6NIr_cYPglk&t=220s)

Apollo 11 carried Neil Armstrong, Buzz Aldrin, and Michael Collins to the Moon in 1969. Its figurative fourth astronaut was the **Apollo Guidance Computer**, or AGC. Brazeal connects that computer to MIT’s development work and the familiar photograph of Margaret Hamilton beside a towering source listing. The code is assembly, a language few people in the room claim to have used professionally.

Brazeal characterizes the software as one giant monolithic source file. The preserved [Apollo 11 source repository](https://github.com/chrislgarry/Apollo-11) actually separates command-module and lunar-module programs into multiple assembly files. Either way, the practical difficulty is familiar: looking at the instructions does not immediately reveal the system’s behavior. The goal is to understand enough of that behavior to investigate its alarms and then simulate a landing.

### From an alarm number to a recovery mechanism

[4:57](https://www.youtube.com/watch?v=6NIr_cYPglk&t=297s)

The first task is to recover an explanation, not change code. During Apollo 11’s final descent, the crew reported program alarms that raised the possibility of aborting the landing. Brazeal recounts five overload alarms before Houston cleared the crew to continue. Given only the source, could you explain why continuing was reasonable?

In VS Code, Brazeal opens a slightly modified Apollo checkout. Searching for `1201` or `1202` can locate a constant, but finding the number does not explain the condition that produces it or the recovery path that follows. He asks: “What does the 1202 program alarm do?”

The response combines repository inspection with web context. Brazeal compares this to calling Mission Control: the developer asks a focused question and receives an explanation backed by a wider body of information. He suggests MCP servers as a way to expand those information sources, but does not demonstrate an MCP integration.

The code investigation identifies two related resource-exhaustion conditions:

| Alarm | Exhausted resource |
|---|---|
| `1202` | Executive scheduler core sets |
| `1201` | VAC areas |

The response points to the octal `1202` value in source and connects it to the executive scheduler’s inability to allocate another core set. That turns a number into a statement about the computer’s capacity to track concurrent work.

The web-derived explanation then connects resource exhaustion to the descent. Brazeal summarizes the cause as an external radar being left on; the historical account is more specific, involving rendezvous-radar configuration and false tracking-angle signals. Recovery restarted selected programs so mission-critical work could continue, rather than simply treating every queued task as equally necessary. **The useful answer explains both the failure condition and why recovery preserved essential behavior.**

Brazeal contrasts the brief interaction with the time he would need to understand the assembly unaided. That is an informal observation during the demo, not a measured productivity benchmark.

### Give the agent a missing module and a fixed evaluator

[8:01](https://www.youtube.com/watch?v=6NIr_cYPglk&t=481s)

The next task moves from explanation to modernization. The [lunar landing guidance source](https://github.com/chrislgarry/Apollo-11/blob/master/Luminary099/LUNAR_LANDING_GUIDANCE_EQUATIONS.agc) contains the adjacent `P65` and `P66` routines. After initially reversing them, Brazeal corrects the distinction: Armstrong used `P66`, while this demonstration targets fully automatic `P65`. Armstrong’s control through `P66` still involved computer-assisted guidance; it did not remove the computer from the descent.

Brazeal now points out that the previous interaction was actually in agent mode, despite his initial chat framing. In the auto mode shown here, the agent can write code and run commands without waiting for a permission click at each step. That permits a continuous loop of investigation, implementation, and execution.

The task has an explicit boundary. Brazeal has already written `simulator.py`, which expects a module named `descent` containing a class named `LunarDescentGuidance`. That class must implement the `P65` algorithm. The simulator exists; the guidance module does not. The agent’s job is to create the missing implementation and make the simulation succeed.

His instruction is deliberately short:

> Run simulator.py until it succeeds.

Then he adds the constraint that makes the task meaningful:

> Do not change simulator.py.

**The evaluator stays fixed while the implementation changes.** Without that boundary, an agent could make the task appear successful by weakening the simulator instead of satisfying it. The autonomous landing here is a software simulation, not operation of a spacecraft.

### Let execution expose what is missing

[10:00](https://www.youtube.com/watch?v=6NIr_cYPglk&t=600s)

The agent begins by running the simulator and investigating the resulting problems. Ball describes repository knowledge as the starting point for choosing commands and tools. Reading individual files then refines the plan: what does the task require, and what is absent? Here, execution exposes the missing `descent` module, and the agent searches the repository for the assembly and tests needed to implement it.

![An editor shows simulator.py, a terminal traceback reporting no module named descent, repository file listings, and an agent message noting tests but no actual descent.py file.](https://ai.engineer/api/talk-essay-media/19f51724a0cf9fafb09aba63682791e597ae8135b453f7f713aef9f8e2274a39)

The agent identifies a missing descent module and investigates tests for clues about its implementation.

Terminal commands continue without presenter intervention. The existing tests help the agent infer the expected `LunarDescentGuidance` interface, and it creates `descent.py`. Brazeal finds that the agent has completed this step before he finishes narrating its investigation.

The generated Python is easier for Brazeal to inspect than assembly. It exposes position, velocity, desired velocity, gravity, and a `P65` guidance routine. The agent has also located the corresponding routine in the indexed historical source. One calculation in that source—velocity difference divided by `TAUVERT`—can be expressed directly in Python:

```python
def velocity_error_acceleration(velocity, desired_velocity, tauvert):
    return tuple(
        (desired - current) / tauvert
        for current, desired in zip(velocity, desired_velocity, strict=True)
    )
```

This expresses the velocity-error component, not the complete guidance implementation. It makes the relationship inspectable: with the same velocity error, a larger time constant produces a smaller acceleration correction.

The agent then runs the simulator. Brazeal reports that the final landing position falls within the simulator’s expected zero-to-one-meter range. He also points to final vertical and horizontal velocities without reading their exact values aloud. The demonstrated result is successful execution against this simulator’s checks; it does not establish flight-ready equivalence with the original guidance software.

### Understand, test, then modernize

[12:17](https://www.youtube.com/watch?v=6NIr_cYPglk&t=737s)

The reusable workflow begins before code generation:

1. **Understand the existing system.** Index the repository and ask what the application does, what individual files contribute, and which styles or conventions matter.
2. **Specify expected behavior.** Use a conversational exchange to predict what should happen for concrete inputs, then have the agent write tests that check those predictions.

For the lunar descent example, that means predicting the behavior of `P65` for given input parameters before asking an agent to encode the expectation in a test. A test is useful only to the extent that its expected result captures the intended behavior.

Brazeal gives a specific reason not to accept every prediction: in another scheduler investigation, the agent could be persuaded that priority zero was either the highest or the lowest priority. It could produce a plausible explanation in either direction. The response is to have the agent surface the relevant source, then inspect the ordering logic yourself. Otherwise, the same misunderstanding can enter both the implementation and its tests.

3. **Modernize small portions.** Convert a bounded part of the code to the desired language or style, then apply the same tests to check that its functionality remains intact.

This keeps the unit of change small enough to understand and review. The agent assists with navigation and translation; the tests preserve a behavioral target across the conversion.

The enterprise counterpart need not involve assembly or spacecraft. The closing discussion proposes moving a Java 8 project to Java 17: tedious modernization work in a repository potentially much larger than the Apollo example. Brazeal is unsure of the Apollo repository’s line count, so its size is not offered as a scaling benchmark. Greenfield projects are also possible, but the demonstration’s distinctive value lies in working through inherited behavior. No enterprise migration or deployment is shown.

### Tests give an agent a way to check its work

[14:35](https://www.youtube.com/watch?v=6NIr_cYPglk&t=875s)

The first audience question asks about checking dependencies across a large codebase. The presenters answer affirmatively, then point back to concrete recovery in the demonstration: discovering missing files and switching from an unavailable `python` command to `python3`. Those examples show the agent responding to local execution failures; they do not demonstrate exhaustive dependency analysis across an enterprise repository.

![An editor displays descent.py above terminal validation results with green checks and “OVERALL VALIDATION: ALL PARAMETERS CORRECT!” The agent panel includes an instruction to run simulator.py until it succeeds without changing that file.](https://ai.engineer/api/talk-essay-media/1ccc6b6bab79f8b9bb0fbf826b41c9cc3a369058b4dcb063be9581e89c0d8d6b)

The simulator’s validation output reports all parameters correct.

The final question identifies the exercise as effectively test-driven development. The answer emphasizes the feedback loop: agents reason and iterate, and tests let them check their own results. A fixed simulator gives the agent something more useful than an instruction to keep trying—it gives each attempt an observable outcome that can guide the next change.

## Resources

- [Augment Code](https://www.augmentcode.com/) — The product's public site, with current offerings and getting-started links.
- [Apollo 11 Guidance Computer source](https://github.com/chrislgarry/Apollo-11) — Browse the preserved assembly source for Apollo 11's command and lunar modules.
- [P65 and P66 lunar landing guidance source](https://github.com/chrislgarry/Apollo-11/blob/master/Luminary099/LUNAR_LANDING_GUIDANCE_EQUATIONS.agc) — Luminary 099 assembly listing containing the P65 guidance equation and adjacent P66 routines.
- [Introducing Remote Agent](https://www.augmentcode.com/blog/introducing-remote-agent) — Augment's launch announcement describes cloud execution and practices for assigning, validating, and reviewing parallel tasks.
- [Augment's ISO/IEC 42001 announcement](https://www.augmentcode.com/blog/augment-code-is-the-first-ai-coding-assistant-to-be-iso-iec-42001-certified) — The vendor describes certification of its AI management system and the governance processes covered.

## Slides

### Innovation partner and platinum sponsors

AWS is the innovation partner; six companies are listed as platinum sponsors.

[0:10](https://www.youtube.com/watch?v=6NIr_cYPglk&t=10s) [AWS is the innovation partner; six platinum sponsor logos appear below.](https://assets.ai.engineer/sites/aiecode2025/sha256/f77b34a64fddfc563657e89c6e3af8f6c629f2d83e036733d58fda3bbfdd1910.webp)

INNOVATION PARTNER
aws

PLATINUM SPONSORS
Graphite
Windsurf
MongoDB®
daily™
augment code
WorkOS

### Expo Sessions

Forrest Brazeal and Matt Ball’s Augment Agent session starts at 3:15 PM, followed by Sam Fertig’s Windsurf session at 3:30 PM. Forrest is an Augment partner; Matt is an Augment solutions architect.

[0:45](https://www.youtube.com/watch?v=6NIr_cYPglk&t=45s) [Schedule lists Augment Agent and Windsurf sessions, their speakers, and start times.](https://assets.ai.engineer/sites/aiecode2025/sha256/0658208b4effb5b03179ea0859f3d9503bc249faa0b9f01c2905a25c990b73cd.webp)

EXPO SESSIONS

THU, JUNE 5, 2025
NOBHILL A&B

3:15 PM → 15 MIN
To the moon! Navigating deep context in legacy code with Augment Agent
Forrest Brazeal, Matt Ball
Augment Code

3:30 PM → 20 MIN
The Eyes Are The (Context) Window to The Soul: How Windsurf Gets to Know You
Sam Fertig
Windsurf

AIE
AI Engineer World's Fair
Microsoft
smol ai

[1:05](https://www.youtube.com/watch?v=6NIr_cYPglk&t=65s) [Schedule listing the Augment Agent and Windsurf expo sessions.](https://assets.ai.engineer/sites/aiecode2025/sha256/7d0f197fedf1bcc4b432209c488af78172ddddc32acc0a965e16b0d6d8f6522a.webp)

EXPO SESSIONS

THU, JUNE 5, 2025
NOBHILL A&B

3:15 PM → 15 MIN
To the moon! Navigating deep context in legacy code with Augment Agent
Forrest Brazeal, Matt Ball
Augment Code

3:30 PM → 20 MIN
The Eyes Are The (Context) Window to The Soul: How Windsurf Gets to Know You
Sam Fertig
Windsurf

AIE
AI Engineer World's Fair
Microsoft
smol ai

### Today's mission

The session introduces Augment Agent and the Apollo 11 guidance computer, then plans to demonstrate what Augment Agent can do with its codebase.

[1:07](https://www.youtube.com/watch?v=6NIr_cYPglk&t=67s) [An Apollo astronaut photograph beside a five-part agenda covering Augment Agent, best practices, the Apollo 11 guidance computer, legacy code, and the moon.](https://assets.ai.engineer/sites/aiecode2025/sha256/c4e0a4acfe60cff784b527c7319e3e736aa6785edddee5854a98ff9c3c185b9a.webp)

Today’s mission

1 Augment Agent
2 AI Agent Best Practices
3 The Apollo 11 Guidance Computer
4 Navigating the (legacy) code
5 To the moon!

AI Engineer World’s Fair June 2025

Interface text:
AIE
AI Engineer World’s Fair
Microsoft
smol ai

### The AI Agent that knows you and your codebase best

Augment presents its Context Engine as understanding how users build software. The presenters plan to use the agent with the Apollo 11 guidance computer code.

[1:19](https://www.youtube.com/watch?v=6NIr_cYPglk&t=79s) [Augment Agent introduction describing its Context Engine and showing installation options for VS Code and JetBrains.](https://assets.ai.engineer/sites/aiecode2025/sha256/09c16218937367d3d8b205eeec78327f55c542093f3f77d1fabe91757fc4b7bb.webp)

The AI Agent that knows you and your codebase best.

NOW WITH CLAUDE SONNET 4 →

The only coding agent with a Context Engine that understands how you build software.

Install now
IJ

www.augmentcode.com

AI Engineer World's Fair June 2025

AIE
aws
AI Engineer World's Fair

### Why Augment Code?

Augment says its Context Engine selects codebase knowledge for models, while its IDE plugins let developers stay in their editors. The slide also lists customer-data security commitments.

[1:33](https://www.youtube.com/watch?v=6NIr_cYPglk&t=93s) [Three columns describe Augment Code’s context engine, IDE support, and security claims.](https://assets.ai.engineer/sites/aiecode2025/sha256/26e1ef63a45610444b7a2c3faccc33f083c1962b39077aa4c56ea9b0ed6f3539.webp)

Why Augment Code?

Context Engine
The only AI coding assistant for production-grade codebases
• Understands your code and how you build software
• Deep context into the most gnarly and unfamiliar codebases

Keep your IDE
One AI solution across editors
• Support for JetBrains, VS Code, Vim
• No forks here

Security
Enterprise-grade security, privacy, terms
• We never train on customer data
• We never sell customer data to model providers
• You can focus on building what’s next

AI Engineer World’s Fair June 2025

AIE
Microsoft
smol ai
AI Engineer World’s Fair

### Mission Tools

Chat supports one-turn questions; Agent handles larger tasks. Remote Agent runs in the cloud and can continue in the background and in parallel.

[2:48](https://www.youtube.com/watch?v=6NIr_cYPglk&t=168s) [Three columns describe Augment Code Chat, Augment Agent, and Remote Agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/3e35f297d70a7934a0ed364ca0245515271fbc766a66373fc21f3d7d1ffade3d.webp)

Mission Tools

1
Augment Code Chat
Use Chat to explore your codebase, quickly get up to speed on unfamiliar code, and get help working through a technical problem.

2
Augment Agent
Use Agent to complete simple and complex tasks across your workflow–implementing a feature, upgrade a dependency, or writing a pull request.

3
Remote Agent
Use Remote Agent to complete tasks across your workflow–implementing a feature, upgrade a dependency, or writing a pull request–all from the cloud.

AI Engineer World’s Fair June 2025

AIE
aws
AI Engineer World’s Fair

[3:36](https://www.youtube.com/watch?v=6NIr_cYPglk&t=216s) [Three columns describe Augment Code Chat, Augment Agent, and Remote Agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/324789e9d510dd16a062a3c44376c18530e7191c10de14dc8aeadd77bfe23a0f.webp)

Mission Tools

1
Augment Code Chat
Use Chat to explore your codebase, quickly get up to speed on unfamiliar code, and get help working through a technical problem.

2
Augment Agent
Use Agent to complete simple and complex tasks across your workflow–implementing a feature, upgrade a dependency, or writing a pull request.

3
Remote Agent
Use Remote Agent to complete tasks across your workflow–implementing a feature, upgrade a dependency, or writing a pull request–all from the cloud.

AI Engineer World’s Fair June 2025

AIE
aws
AI Engineer World’s Fair

### Apollo 11 Mission Brief

Apollo 11’s Saturn V launched with Armstrong, Aldrin and Collins. The speaker introduces the Apollo Guidance Computer as a “fourth astronaut,” setting up the legacy-code example.

[3:41](https://www.youtube.com/watch?v=6NIr_cYPglk&t=221s) [Apollo 11 mission brief describes the 1969 Moon landing and names the three astronauts, alongside a Saturn V launch photograph.](https://assets.ai.engineer/sites/aiecode2025/sha256/87f4ef6946f2c6b36aa69e85e4db357bf9c071c00d2aa4ccd00e62aac92ada8e.webp)

Mission brief
Apollo 11

NASA mission
1969

The first time humans land on the moon

July 16: the Saturn V rocket launches from the Kennedy Space Center with astronauts Neil Armstrong, Buzz Aldrin, and Michael Collins

Interface text:
AIE
AI Engineer World’s Fair  June 2025
AI Engineer World’s Fair
Microsoft
smol ai

### Apollo 11 Guidance Computer

The Apollo Guidance Computer used assembly code to land the Lunar Module. The presenters aim to navigate that legacy code with Augment Agent and understand it well enough to land the module themselves.

[4:04](https://www.youtube.com/watch?v=6NIr_cYPglk&t=244s) [The Apollo Guidance Computer is described as assembly-language code used to land the lunar module, with photographs of the module and computer.](https://assets.ai.engineer/sites/aiecode2025/sha256/f0402296fd2b64cfde906a14c5ccb2d04c7adb29280b0c7e74e70624e1759187.webp)

Mission brief

Apollo 11

Guidance Computer (AGC)

Used to land the Lunar Module

Written in assembly language

The ultimate legacy codebase...

...can we navigate it well enough to understand and land the Lunar Module?

AI Engineer World’s Fair June 2025

Interface text:
AIE
Microsoft
smol ai
AI Engineer World’s Fair

### Apollo guidance code in VS Code

The presenter opens a slightly modified Apollo 11 codebase in VS Code. Its assembly uses short commands, and he says searching for 1201 or 1202 won't reveal what the alarms mean.

[6:11](https://www.youtube.com/watch?v=6NIr_cYPglk&t=371s) [VS Code displays the automatic maneuvers assembly file and its comments.](https://assets.ai.engineer/sites/aiecode2025/sha256/637164b7bc899724582cd44d4805007967fa7e75684ec7a296f00ff27cd324ae.webp)

AUTOMATIC_MANEUVERS.agc

38  AHFNOROT    EXTEND
41              EXTEND
42              BZMF    FREECONT
43              CA      RCSFLAGS    # SEE IF RATE FILTER HAS BEEN INITIALIZED
44              MASK    BIT14
45              CCS A       # IF SO, PROCEED WITH ATTITUDE CONTROL
46              TCF REINIT      # IF NOT, RECYCLE TO INITIALIZE FILTER
47                          # AUTOMATIC CONTROL YET
48              EXTEND
49              READ    CHAN31
50              MASK    BIT13
51              EXTEND
52              BZMF    HOLDFUNC

55  AUTOCONT    CA      HOLDFLAG    # IF HOLDFLAG IS +, GO TO GRABANG.
56              EXTEND              # OTHERWISE, GO TO ATTHOLD.
57              BZMF    ATTHOLD
58              TCF GRABANG

60  # MINIMUM IMPULSE CONTROL

62  FREECONT    CAF ONE
63              TS  HOLDFLAG    # RESET HOLDFLAG

Interface text:
apollo-11-workshop
EXPLORER
APOLLO-11-WORKSHOP
.github
Comanche055
AGC_BLOCK_TWO_SELF-CHECK...
ALARM_AND_ABORT.agc
ANGLFIND.agc
ASSEMBLY_AND_OPERATION_IN...
AUTOMATIC_MANEUVERS.agc
CM_BODY_ATTITUDE.agc
CM_ENTRY_DIGITAL_AUTOPILO...
CONIC_SUBROUTINES.agc
CONTRACT_AND_APPROVALS.agc
CSM_GEOMETRY.agc
DISPLAY_INTERFACE_ROUTINES...
DOWN-TELEMETRY_PROGRAM.a...
DOWNLINK_LISTS.agc
ENTRY_LEXICON.agc
ERASABLE_ASSIGNMENTS.agc
EXECUTIVE.agc
OUTLINE
TIMELINE
mulator.js
simulator.py 1
Settings
AUTOMATIC_MANEUVERS.agc
test_descent.p...
Comanche055 > AUTOMATIC_MANEUVERS.agc
chrislgarry (8 years ago)
Ln 48, Col 15 (6 selected)
Tab Size: 4
UTF-8
LF
Plain Text
Augment

### Asking about the 1202 alarm

The presenter asks Augment Chat about the 1202 program alarm alongside Apollo guidance code. He notes that searching the code for the alarm number alone would not explain its meaning.

[6:32](https://www.youtube.com/watch?v=6NIr_cYPglk&t=392s) [Augment chat contains a question about the 1202 program alarm beside Apollo guidance code.](https://assets.ai.engineer/sites/aiecode2025/sha256/81976ea6364d6f452a646575c6e9da984896e460e59f15ed7bb5789ae0c5905b.webp)

what do[illegible] the 1202 program alarm
do?

48  SXTNB     SLOAD*  RTB     # PUSHDOWN  00,02,04,(17D-19D),32D-36D
63            SIN DMP
64            STADR
65            STODL   STARM   +2  # SIN(SA)SIN(TA)
67            COS
68            STOVL   STARM   +4
69                    STARM       # STARM = 32D
70            MXV VSL1
71                NB1NB2
72            STORE   32D
73            RVQ
76  SXTLOGIC  CAF 10DEGS-     # CORRECT FOR 19.775 DEGREE OFFSET
77            ADS MPAC
78            CAF QUARTER
79            TC SHORTMP
80            TC DANZIG
81  # Page 286
82  # CALCSXA COMPUTES THE SEXTANT SHAFT AND TRUNNION ANGLES REQUIRED TO POSITION THE OPTICS SUC[illegible]
83  # OF-SIGHT LIES ALONG THE STAR VECTOR. THE ROUTINE TAKES THE GIVEN STAR VECTOR AND EXPRESSE[illegible]
84  # ERENCED TO THE OPTICS COORDINATE SYSTEM. IN ADDITION IT SETS UP THREE UNIT VECTORS DEFINI[illegible]
85  # REFERENCED TO THE OPTICS COORDINATE SYSTEM.

Interface text:
AUGMENT
New Agent
Augment Memories
apollo-11-workshop
CSM_GEOMETRY.agc
Agent Auto
Comanche055 > CSM_GEOMETRY.agc
simulator.py 1
Settings
CSM_GEOMETRY.agc
test_descent.py 1
Ln 1, Col 1
Tab Size: 4
UTF-8
LF
Plain Text
Augment
AIE
Microsoft
smol ai
AI Engineer World's Fair

### Explaining the 1202 alarm

Augment connects the 1202 alarm to a rendezvous radar left on during Apollo 11. Its response says the extra tasks overloaded the computer, while Mission Control judged it safe to continue the landing.

[7:27](https://www.youtube.com/watch?v=6NIr_cYPglk&t=447s) [Augment displays historical context for the Apollo 11 alarm beside guidance code.](https://assets.ai.engineer/sites/aiecode2025/sha256/45450a68ca397f9f1206628bee46c88314975777a1983ac6e68a22a0008ff414.webp)

Historical significance:

The 1202 alarm (along with 1201 "No VAC Areas") famously occurred during the Apollo 11 lunar landing. The alarms were caused by the rendezvous radar being left on, which overloaded the computer with unnecessary tasks. Mission Control determined it was safe to continue, [illegible] Neil

48  SXTNB    SLOAD*  RTB    # PUSHDOWN  00,02,04,(17D-19D),32D-36D
63           SIN DMP
64           STADR
65           STODL   STARM   +2  # SIN(SA)SIN(TA)
67           COS
68           STOVL   STARM   +4
69                   STARM       # STARM = 32D
70           MXV VSL1
71                   NB1NB2
72           STORE   32D
73           RVQ
76  SXTLOGIC CAF 10DEGS-    # CORRECT FOR 19.775 DEGREE OFFSET
77           ADS MPAC
78           CAF QUARTER
79           TC SHORTMP
80           TC DANZIG
81  # Page 286
82  # CALCSXA COMPUTES THE SEXTANT SHAFT AND TRUNNION ANGLES REQUIRED TO POSITION THE OPTICS SUC[illegible]
83  # OF-SIGHT LIES ALONG THE STAR VECTOR. THE ROUTINE TAKES THE GIVEN STAR VECTOR AND EXPRESSE[illegible]
84  # ERENCED TO THE OPTICS COORDINATE SYSTEM. IN ADDITION IT SETS UP THREE UNIT VECTORS DEFINI[illegible]
85  # REFERENCED TO THE OPTICS COORDINATE SYSTEM.

Interface text:
AUGMENT
What does the 1202 ...
Augment Memories
apollo-11-workshop
CSM_GEOMETRY.agc
Ask or instruct Augment Agent
Agent Auto
[illegible]mulator.js
simulator.py 1
Settings
CSM_GEOMETRY.agc
test_descent.py 1
Comanche055 > CSM_GEOMETRY.agc
Ln 1, Col 1  Tab Size: 4  UTF-8  LF  Plain Text  Augment
AIE
Microsoft
smol ai
AI Engineer World's Fair

[7:31](https://www.youtube.com/watch?v=6NIr_cYPglk&t=451s) [Augment explains the Apollo 11 alarm beside Apollo guidance code.](https://assets.ai.engineer/sites/aiecode2025/sha256/80eb8d691482e71267c22bb82c0ea610d2cee8b8e100e0c80802e7a6215ffd1c.webp)

[illegible] landing. The alarms were caused by the rendezvous radar being left on, which overloaded the computer with unnecessary tasks. Mission Control determined it was safe to continue, and Neil Armstrong successfully landed with these alarms intermittently appearing.

Related alarm[illegible]

48  SXTNB    SLOAD*  RTB    # PUSHDOWN  00,02,04,(17D-19D),32D-36D
63           SIN DMP
64           STADR
65           STODL   STARM   +2  # SIN(SA)SIN(TA)
67           COS
68           STOVL   STARM   +4
69                   STARM       # STARM = 32D
70           MXV VSL1
71                   NB1NB2
72           STORE   32D
73           RVQ
76  SXTLOGIC CAF 10DEGS-    # CORRECT FOR 19.775 DEGREE OFFSET
77           ADS MPAC
78           CAF QUARTER
79           TC SHORTMP
80           TC DANZIG
81  # Page 286
82  # CALCSXA COMPUTES THE SEXTANT SHAFT AND TRUNNION ANGLES REQUIRED TO POSITION THE OPTICS SUC[illegible]
83  # OF-SIGHT LIES ALONG THE STAR VECTOR. THE ROUTINE TAKES THE GIVEN STAR VECTOR AND EXPRESSE[illegible]
84  # ERENCED TO THE OPTICS COORDINATE SYSTEM. IN ADDITION IT SETS UP THREE UNIT VECTORS DEFINI[illegible]
85  # REFERENCED TO THE OPTICS COORDINATE SYSTEM.

Interface text:
AUGMENT
What does the 1202 ...
Augment Memories
apollo-11-workshop
CSM_GEOMETRY.agc
Ask or instruct Augment Agent
Agent Auto
[illegible]mulator.js
simulator.py 1
Settings
CSM_GEOMETRY.agc
test_descent.py 1
Comanche055 > CSM_GEOMETRY.agc
Ln 1, Col 1  Tab Size: 4  UTF-8  LF  Plain Text  Augment

### 1202 alarm explanation

Beside the Apollo guidance code, Augment summarizes the 1202 alarm: the computer was handling too many concurrent jobs and ran out of memory to track them.

[7:47](https://www.youtube.com/watch?v=6NIr_cYPglk&t=467s) [Augment summarizes the 1202 alarm beside Apollo guidance code.](https://assets.ai.engineer/sites/aiecode2025/sha256/e00054c0d007e886be3435ec15693f1428a756914760448aa03ff490ef9cdac9.webp)

[illegible] interpretive programs)
• 1203: "Waitlist Overflow - Too Many Tasks"

The 1202 alarm essentially means the computer is trying to do too many things at once and has run out of memory to track all the concurrent jobs.

48  SXTNB       SLOAD*  RTB     # PUSHDOWN  00,02,04,(17D-19D),32D-36D
63              SIN DMP
64              STADR
65              STODL   STARM   +2  # SIN(SA)SIN(TA)
67              COS
68              STOVL   STARM   +4
69                      STARM       # STARM = 32D
70              MXV VSL1
71                  NB1NB2
72              STORE   32D
73              RVQ
76  SXTLOGIC    CAF 10DEGS-     # CORRECT FOR 19.775 DEGREE OFFSET
77              ADS MPAC
78              CAF QUARTER
79              TC  SHORTMP
80              TC  DANZIG
81  # Page 286
82  # CALCSXA COMPUTES THE SEXTANT SHAFT AND TRUNNION ANGLES REQUIRED TO POSITION THE OPTICS SUC[illegible]
83  # OF-SIGHT LIES ALONG THE STAR VECTOR. THE ROUTINE TAKES THE GIVEN STAR VECTOR AND EXPRESSE[illegible]
84  # ERENCED TO THE OPTICS COORDINATE SYSTEM. IN ADDITION IT SETS UP THREE UNIT VECTORS DEFINI[illegible]
85  # REFERENCED TO THE OPTICS COORDINATE SYSTEM.

Interface text:
AUGMENT
What does the 1202 ...
apollo-11-workshop
simulator.py 1
Settings
CSM_GEOMETRY.agc
test_descent.py 1
Comanche055 > CSM_GEOMETRY.agc
Augment Memories
apollo-11-workshop
CSM_GEOMETRY.agc
Ask or instruct Augment Agent
Agent  Auto
Ln 1, Col 1  Tab Size: 4  UTF-8  LF  Plain Text  Augment

### Navigating Legacy Code: Code Modernization

The proposed exercise modernizes the automatic P65 lunar descent routine in Python. The slide contrasts it with P66, the manual-assistance mode Armstrong used to land the Eagle.

[8:05](https://www.youtube.com/watch?v=6NIr_cYPglk&t=485s) [Slide compares P66 manual assistance with a proposed Python modernization of P65, alongside lunar guidance code.](https://assets.ai.engineer/sites/aiecode2025/sha256/b4e313d0426dfb9178d76a8feb9339ff02c4da6024d91413926c49de01ec7cdd.webp)

Mission launch
Navigating Legacy Code: Code Modernization

The P65 Lunar Descent Routine
• Armstrong used mode P66 (manual assistance) to land the Eagle
• Can we modernize P65 (full auto) to land on the moon in Python?

GUIDANCE FOR P65

VERTGUID    CCS WCHVERT
            TCF P67VERT    # POSITIVE NON-ZERO ---> P67
            TCF P66VERT    # +0

# THE P65 GUIDANCE EQUATION IS AS FOLLOWS --
#             V̅2̅F̅G̅ - V̅G̅U̅
#       ACG = -----------
#               TAUVERT

P65VERT     TC  INTPRET
            VLOAD  VSU
                V2FG
                VGU
            V/SC   GOTO
                TAUVERT
                AFCCALC1
# Page 816
# GUIDANCE FOR P66

P66VERT     TC  POSTJUMP
            CADR  P66VERTA

P67VERT     TC  PHASCHNG   # TERMINATE GROUP 3.
            OCT 00003

            TC  INTPRET
            VLOAD  GOTO

AI Engineer World’s Fair June 2025
AIE
Microsoft
smol ai

Interface text:
LUNAR_LANDING_GUIDANCE_EQUATIONS.agc
Luminary099 > LUNAR_LANDING_GUIDANCE_EQUATIONS.agc
Lines 892–926

[8:19](https://www.youtube.com/watch?v=6NIr_cYPglk&t=499s) [Slide contrasts Armstrong’s P66-assisted landing with a proposal to modernize the automatic P65 routine in Python, alongside lunar guidance code.](https://assets.ai.engineer/sites/aiecode2025/sha256/4c5294990b0aeea6fb44b02ebfc0ef5ef5bf11b6a3746dbf90ad1d0ecd5eae62.webp)

Mission launch
Navigating Legacy Code: Code Modernization

The P65 Lunar Descent Routine
• Armstrong used mode P66 (manual assistance) to land the Eagle
• Can we modernize P65 (full auto) to land on the moon in Python?

GUIDANCE FOR P65

VERTGUID    CCS WCHVERT
            TCF P67VERT    # POSITIVE NON-ZERO ---> P67
            TCF P66VERT    # +0

# THE P65 GUIDANCE EQUATION IS AS FOLLOWS --
#             V̅2̅F̅G̅ - V̅G̅U̅
#       ACG = -----------
#               TAUVERT

P65VERT     TC  INTPRET
            VLOAD  VSU
                V2FG
                VGU
            V/SC   GOTO
                TAUVERT
                AFCCALC1
# Page 816
# GUIDANCE FOR P66

P66VERT     TC  POSTJUMP
            CADR  P66VERTA

P67VERT     TC  PHASCHNG   # TERMINATE GROUP 3.
            OCT 00003

            TC  INTPRET
            VLOAD  GOTO

AI Engineer World’s Fair June 2025
AIE
aws

Interface text:
LUNAR_LANDING_GUIDANCE_EQUATIONS.agc
Luminary099 > LUNAR_LANDING_GUIDANCE_EQUATIONS.agc
Lines 892–926

### Agent interface and Apollo guidance code

The presenter explains that Agent’s Auto mode can write or run code without prompting. The editor shows Apollo guidance code beside an earlier explanation of the 1202 alarm.

[8:55](https://www.youtube.com/watch?v=6NIr_cYPglk&t=535s) [An editor shows Apollo guidance code beside an agent panel discussing computer alarms.](https://assets.ai.engineer/sites/aiecode2025/sha256/ed69715bdd6b9457d0990db24c053a3bda263029620e1abd11f00a9c55a1a4a6.webp)

Augment response:
[illegible] memory exhaustion for interpretive programs)
• 1203: "Waitlist Overflow - Too Many Tasks"

The 1202 alarm essentially means the computer is trying to do too many things at once and has run out of memory to track all the concurrent jobs.

CSM_GEOMETRY.agc:
48  SXTNB       SLOAD*  RTB     # PUSHDOWN  00,02,04,(17D-19D),32D-36D
63              SIN DMP
64              STADR
65              STODL   STARM   +2  # SIN(SA)SIN(TA)
67              COS
68              STOVL   STARM   +4
69                  STARM       # STARM = 32D
70              MXV VSL1
71                  NB1NB2
72              STORE   32D
73              RVQ
76  SXTLOGIC    CAF 10DEGS-     # CORRECT FOR 19.775 DEGREE OFFSET
77              ADS MPAC
78              CAF QUARTER
79              TC  SHORTMP
80              TC  DANZIG
81  # Page 286
82  # CALCSXA COMPUTES THE SEXTANT SHAFT AND TRUNNION ANGLES REQUIRED TO POSITION THE OPTICS SUC[illegible]
83  # OF-SIGHT LIES ALONG THE STAR VECTOR. THE ROUTINE TAKES THE GIVEN STAR VECTOR AND EXPRESSE[illegible]
84  # ERENCED TO THE OPTICS COORDINATE SYSTEM. IN ADDITION IT SETS UP THREE UNIT VECTORS DEFINI[illegible]
85  # REFERENCED TO THE OPTICS COORDINATE SYSTEM.

Interface text:
apollo-11-workshop
AUGMENT
What does the 1202 ...
simulator.py 1
Settings
CSM_GEOMETRY.agc
test_descent.py 1
Comanche055 > CSM_GEOMETRY.agc
Augment Memories
apollo-11-workshop
CSM_GEOMETRY.agc
Ask or instruct Augment Agent
Agent  Auto
Ln 1, Col 1  Tab Size: 4  UTF-8  LF  Plain Text  Augment
AIE
AI Engineer World's Fair
Microsoft
smol ai

### Lunar descent simulator demonstration

The presenter prepares to ask Augment Agent to run a lunar descent simulator. The simulator imports a guidance class from a file he says has yet to be written and checks touchdown time, velocity, and altitude.

[9:16](https://www.youtube.com/watch?v=6NIr_cYPglk&t=556s) [Python simulator code lists expected touchdown time, velocity and altitude checks.](https://assets.ai.engineer/sites/aiecode2025/sha256/cc24aec499505feee5cf24730912780aa8384aa7c2488947236ee5d1a5d47d7e.webp)

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from descent import LunarDescentGuidance

def validate_simulation_results(actual_time, actual_velocity, actual_altitude, actual_hor_ve[illegible]
    """
    Validate simulation results against expected parameters and provide detailed feedback.

    Expected results:
    - TOUCHDOWN at time: 7.1 seconds (exact)
    - Final X velocity: between 0 and 1 m/s
    - Final Y velocity: should be less than 0 m/s
    - Final Z velocity: should be less than 20 and greater than 0 m/s
    - Final altitude: between -1 and 1 m
    - Horizontal velocity at touchdown: between 0 and 1 m/s
    - Vertical velocity at touchdown: less than 0 m/s
    """
    print("\n" + "="*60)
    print("SIMULATION RESULTS VALIDATION")
    print("="*60)

    # Display final position (without validation)
    print(f"📍 FINAL POSITION: [{actual_position[0]:.1f}, {actual_position[1]:.1f}, {actual_[illegible]

Interface text:
apollo-11-workshop
EXPLORER
APOLLO-11-WORKSHOP
Comanche055
Luminary099
node_modules
Translations
.editorconfig
.gitignore
.markdownlint.yml
bun.lockb
CONTRIBUTING.md
LICENSE.md
package-lock.json
package.json
README.md
simulator.js
simulator.py
 test_descent.py
test_descent.test.js
OUTLINE
TIMELINE
Settings
CSM_GEOMETRY.agc
Forrest Brazeal (1 week ago)
Ln 4, Col 9 (4 selected)
Spaces: 4
UTF-8
LF
Python 3.9.6 64-bit
Augment

[9:38](https://www.youtube.com/watch?v=6NIr_cYPglk&t=578s) [An Augment prompt is being entered beside the simulator code.](https://assets.ai.engineer/sites/aiecode2025/sha256/6cb6b75f4fe80be5c251f8f47538a58f4142eb0b2357951988589ffe34f245ae.webp)

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from descent import LunarDescentGuidance

def validate_simulation_results(actual_time, actual_velocity, actual_altitude, actual_hor_ve[illegible]
    """
    Validate simulation results against expected parameters and provide detailed feedback.

    Expected results:
    - TOUCHDOWN at time: 7.1 seconds (exact)
    - Final X velocity: between 0 and 1 m/s
    - Final Y velocity: should be less than 0 m/s
    - Final Z velocity: should be less than 20 and greater than 0 m/s
    - Final altitude: between -1 and 1 m
    - Horizontal velocity at touchdown: between 0 and 1 m/s
    - Vertical velocity at touchdown: less than 0 m/s
    """
    print("\n" + "="*60)
    print("SIMULATION RESULTS VALIDATION")
    print("="*60)

    # Display final position (without validation)
    print(f"📍 FINAL POSITION: [{actual_position[0]:.1f}, {actual_position[1]:.1f}, {actual_[illegible]

Augment conversation:
- 1203: "Waitlist Overflow - Too Many Tasks"

The 1202 alarm essentially means the computer is trying to do too many things at once and has run out of memory to track all the concurrent jobs.

Prompt being entered:
run simu

Interface text:
AUGMENT
What does the 1202 ...
Augment Memories
apollo-11-workshop
simulator.py
Selection
Agent
Auto
Settings
CSM_GEOMETRY.agc
test_descent.py
Forrest Brazeal (1 week ago)
Ln 4, Col 21 (20 selected)
Spaces: 4
UTF-8
LF
Python 3.9.6 64-bit
Augment
AIE
AI Engineer World's Fair
Microsoft
smol ai

### Simulator task and constraint

The presenter asks Augment to run the lunar descent simulator until it succeeds while leaving simulator.py unchanged. The simulator checks touchdown time, velocities and altitude.

[9:46](https://www.youtube.com/watch?v=6NIr_cYPglk&t=586s) [The prompt asks Augment to run the simulator until it succeeds without changing the simulator file.](https://assets.ai.engineer/sites/aiecode2025/sha256/45138393d21710cfa8a157ce5449074eb29913d5efe586ef5e09b8d260d145ef.webp)

1203: "Waitlist Overflow - Too Many Tasks"

The 1202 alarm essentially means the computer is trying to do too many things at once and has run out of memory to track all the concurrent jobs.

run simulator.py until it succeeds,
do not change simulator.p

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from descent import LunarDescentGuidance

def validate_simulation_results(actual_time, actual_velocity, actual_altitude, actual_hor_ve[illegible]
    """
    Validate simulation results against expected parameters and provide detailed feedback.

    Expected results:
    - TOUCHDOWN at time: 7.1 seconds (exact)
    - Final X velocity: between 0 and 1 m/s
    - Final Y velocity: should be less than 0 m/s
    - Final Z velocity: should be less than 20 and greater than 0 m/s
    - Final altitude: between -1 and 1 m
    - Horizontal velocity at touchdown: between 0 and 1 m/s
    - Vertical velocity at touchdown: less than 0 m/s
    """
    print("\n" + "="*60)
    print("SIMULATION RESULTS VALIDATION")
    print("="*60)

    # Display final position (without validation)
    print(f"📍 FINAL POSITION: [{actual_position[0]:.1f}, {actual_position[1]:.1f}, {actual_[illegible]

Interface text:
AUGMENT
What does the 1202 ...
Augment Memories
apollo-11-workshop
simulator.py
Selection
Agent Auto
simulator.js
Settings
CSM_GEOMETRY.agc
test_descent.py
Forrest Brazeal (1 week ago)
Ln 4, Col 21 (20 selected)
Spaces: 4
UTF-8
LF
Python 3.9.6 64-bit
Augment
AIE
AI Engineer World's Fair
aws

### Agent starts the simulator

Augment begins working through the simulator task without modifying the file. The terminal shows 13 tests passing, followed by a failed run because the python command is unavailable.

[9:59](https://www.youtube.com/watch?v=6NIr_cYPglk&t=599s) [Augment starts the task; the terminal shows passing tests and a Python command that was not found.](https://assets.ai.engineer/sites/aiecode2025/sha256/2825830d9b76529a6d81c6c7ebb9d09d13323050fcebd0a5ea0f6fceaf249d5e.webp)

Augment
I'll run the simulator.py file and work through any issues that arise without modifying the simulator.py file itself.

Terminal
$ python simulator.py

simulator.py
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from descent import LunarDescentGuidance

def validate_simulation_results(actual_time, actual_velocity, actual_altitude, actual_hor_ve[illegible]
    """
    Validate simulation results against expected parameters and provide detailed feedback.

    Expected results:

Terminal output:
llo-11-workshop && python3 -m pytest test_descent.py -v
/Library/Developer/CommandLineTools/usr/bin/python3: No module named pytest
forrestbrazeal@Random-Forest-LLC-Macbook-Pro apollo-11-workshop % :
forrestbrazeal@Random-Forest-LLC-Macbook-Pro apollo-11-workshop % cd /Users/forrestbrazeal/apollo-11-workshop && python3 test_descent.py
........P65 Vertical Descent Guidance Started
......
----------------------------------------------------------------------
Ran 13 tests in 0.011s

OK
forrestbrazeal@Random-Forest-LLC-Macbook-Pro apollo-11-workshop % :
forrestbrazeal@Random-Forest-LLC-Macbook-Pro apollo-11-workshop % python simulator.py
zsh: command not found: python

Interface text:
AUGMENT
What does the 1202 ...
Augment Memories
apollo-11-workshop
simulator.py
Selection
Ask or instruct Augment Agent
Agent Auto
PROBLEMS 2
OUTPUT
DEBUG CONSOLE
TERMINAL
PORTS
AUGMENT NEXT EDIT
zsh
Augment
Forrest Brazeal (1 week ago)
Ln 4, Col 1 (40 selected)
Spaces: 4
UTF-8
LF
Python 3.9.6 64-bit
AIE
AI Engineer World's Fair
Microsoft
smol ai

### Missing simulator module

Augment runs the simulator without changing simulator.py. After `python` is not found, `python3` reaches the import and fails because the descent module is missing.

[10:03](https://www.youtube.com/watch?v=6NIr_cYPglk&t=603s) [The simulator run fails because its descent module cannot be found.](https://assets.ai.engineer/sites/aiecode2025/sha256/7160993843af053e6cea81a21c4a2b94460eebaad66dbd2664b198d4c0c2009f.webp)

Augment
I'll run the simulator.py file and work through any issues that arise without modifying the simulator.py file itself.

Terminal
$ python simulator.py

simulator.py
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from descent import LunarDescentGuidance

def validate_simulation_results(actual_time, actual_velocity, actual_altitude, actual_hor_ve[illegible]
    """
    Validate simulation results against expected parameters and provide detailed feedback.

    Expected results:

Terminal output:
Ran 13 tests in 0.011s
OK
forrestbrazeal@Random-Forest-LLC-Macbook-Pro apollo-11-workshop % python simulator.py
zsh: command not found: python
forrestbrazeal@Random-Forest-LLC-Macbook-Pro apollo-11-workshop % python3 simulator.py
Traceback (most recent call last):
  File "/Users/forrestbrazeal/apollo-11-workshop/simulator.py", line 4, in <module>
    from descent import LunarDescentGuidance
ModuleNotFoundError: No module named 'descent'

Interface text:
AUGMENT
What does the 1202 ...
Augment Memories
apollo-11-workshop
simulator.py
Selection
Ask or instruct Augment Agent
Agent Auto
Settings
CSM_GEOMETRY.agc
test_descent.py
PROBLEMS 2
OUTPUT
DEBUG CONSOLE
TERMINAL
PORTS
AUGMENT NEXT EDIT
zsh
Augment
Forrest Brazeal (1 week ago)
Ln 4, Col 1 (40 selected)
Spaces: 4
UTF-8
LF
Python 3.9.6 64-bit
AIE
AI Engineer World's Fair
Microsoft
smol ai

### Investigating the missing descent module

After the simulator fails to import descent, Augment checks the workspace for a file containing LunarDescentGuidance.

[10:09](https://www.youtube.com/watch?v=6NIr_cYPglk&t=609s) [Augment identifies the missing descent module and begins checking available files.](https://assets.ai.engineer/sites/aiecode2025/sha256/04f9e5de211fc16f199214652ef70938a1c5ed0e2d442df41a0dae0e789eeb92.webp)

The simulator.py is trying to import from a module called 'descent' which doesn't exist. Let me check what files are available in the workspace:

Read directory

Terminal
$ python3 simulator.py

simulator.py:
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from descent import LunarDescentGuidance

def validate_simulation_results(actual_time, actual_velocity, actual_altitude, actual_hor_ve[illegible]
    """
    Validate simulation results against expected parameters and provide detailed feedback.

    Expected results:

Terminal output:
Ran 13 tests in 0.011s
OK
python simulator.py
zsh: command not found: python
python3 simulator.py
Traceback (most recent call last):
  File "/Users/forrestbrazeal/apollo-11-workshop/simulator.py", line 4, in <module>
    from descent import LunarDescentGuidance
ModuleNotFoundError: No module named 'descent'

Interface text:
AUGMENT
What does the 1202 ...
apollo-11-workshop
simulator.js
simulator.py 1
Settings
CSM_GEOMETRY.agc
test_descent.py 1
PROBLEMS 2
OUTPUT
DEBUG CONSOLE
TERMINAL
PORTS
AUGMENT NEXT EDIT
zsh
Augment
Augment Memories
simulator.py
Selection
Ask or instruct Augment Agent
Agent Auto
Forrest Brazeal (1 week ago)
Ln 4, Col 1 (40 selected)
Spaces: 4
UTF-8
LF
Python 3.9.6 64-bit
AIE
AI Engineer World's Fair
aws

[10:29](https://www.youtube.com/watch?v=6NIr_cYPglk&t=629s) [The simulator imports LunarDescentGuidance while the terminal reports that the descent module is missing.](https://assets.ai.engineer/sites/aiecode2025/sha256/9eca62970eeae515641d3c7495959331d19b4f55a482096648d0d7ccca91842b.webp)

Read file
simulator.py

Now I need to check if there's a descent.py file that contains the LunarDescentGuidance class:

Read directory
.

simulator.py:
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from descent import LunarDescentGuidance

def validate_simulation_results(actual_time, actual_velocity, actual_altitude, actual_hor_ve[illegible]
    """
    Validate simulation results against expected parameters and provide detailed feedback.

    Expected results:

Terminal output:
Ran 13 tests in 0.011s
OK
python simulator.py
zsh: command not found: python
python3 simulator.py
Traceback (most recent call last):
  File "/Users/forrestbrazeal/apollo-11-workshop/simulator.py", line 4, in <module>
    from descent import LunarDescentGuidance
ModuleNotFoundError: No module named 'descent'

Interface text:
AUGMENT
What does the 1202 ...
apollo-11-workshop
simulator.js
simulator.py 1
Settings
CSM_GEOMETRY.agc
test_descent.py 1
PROBLEMS 2
OUTPUT
DEBUG CONSOLE
TERMINAL
PORTS
AUGMENT NEXT EDIT
zsh
Augment
Augment Memories
simulator.py
Selection
Ask or instruct Augment Agent
Agent Auto
Forrest Brazeal (1 week ago)
Ln 4, Col 1 (40 selected)
Spaces: 4
UTF-8
LF
Python 3.9.6 64-bit
AIE
AI Engineer World's Fair
Microsoft
smol ai

### Searching the project files

After finding that descent.py is missing, Augment searches the project for Python files that might contain LunarDescentGuidance. The terminal also lists JavaScript files as the agent explores the codebase.

[10:34](https://www.youtube.com/watch?v=6NIr_cYPglk&t=634s) [Augment searches for the missing module, with Python and JavaScript file listings in the terminal.](https://assets.ai.engineer/sites/aiecode2025/sha256/493d5c796d55f2233c6a395b77d97950b3e00302d103799bf82abf7043a097be.webp)

Augment:
I can see there's no descent.py file in the root directory. Let me search for any Python files that might contain the LunarDescentGuidance class:

Augment Context Engine

simulator.py:
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from descent import LunarDescentGuidance

def validate_simulation_results(actual_time, actual_velocity, actual_altitude, actual_hor_ve[illegible]
    """
    Validate simulation results against expected parameters and provide detailed feedback.

    Expected results:

Terminal:
File "/Users/forrestbrazeal/apollo-11-workshop/simulator.py", line 4, in <module>
    from descent import LunarDescentGuidance
ModuleNotFoundError: No module named 'descent'

find . -name "*.py" -o -name "*.js" | grep -v node_modules | head -10
./test_descent.test.js
./test_descent.py
./simulator.py
./simulator.js

ls -la *.js
-rw-r--r--  1 forrestbrazeal  staff  13135 Jun 1 10:49 simulator.js
-rw-r--r--  1 forrestbrazeal  staff   4787 Jun 2 08:15 test_descent.test.js

Interface text:
apollo-11-workshop
AUGMENT
simulator.js
simulator.py 1
Settings
CSM_GEOMETRY.agc
test_descent.py 1
What does the 1202 ...
Augment Memories
apollo-11-workshop
simulator.py
Selection
Ask or instruct Augment Agent
Agent Auto
PROBLEMS 2
OUTPUT
DEBUG CONSOLE
TERMINAL
PORTS
AUGMENT NEXT EDIT
zsh
Augment
Forrest Brazeal (1 week ago)
Ln 4, Col 1 (40 selected)
Spaces: 4
UTF-8
LF
Python 3.9.6 64-bit
Augment
AIE
AI Engineer World's Fair
aws

## Full transcript

[0:00](https://www.youtube.com/watch?v=6NIr_cYPglk&t=0s) [upbeat music] Welcome, everyone.

[0:16](https://www.youtube.com/watch?v=6NIr_cYPglk&t=16s) Thank you so much for coming. My name is Forrest, this is Matt, uh, and we're gonna be talking to you today about Augment Agent and specifically legacy code, how we get the most out of gnarly legacy code bases using an AI agent.

[0:30](https://www.youtube.com/watch?v=6NIr_cYPglk&t=30s) Uh, so I do not work for Augment Code. Um, I am a friend and partner of Augment Code, uh, so I helped to put this talk together. Matt is from Augment Code, so he's gonna be your best person to come to with your most detailed technical questions after the session.

[0:42](https://www.youtube.com/watch?v=6NIr_cYPglk&t=42s) Matt, anything you wanna, uh, say about yourself?

[0:45](https://www.youtube.com/watch?v=6NIr_cYPglk&t=45s) Yeah. Uh, I was once a software engineer and then got into the developer tool space. Um, I was at Postman for a number of years and then got really excited by the, the AI boom.

[0:55](https://www.youtube.com/watch?v=6NIr_cYPglk&t=55s) So I've been at Augment for the last two years or so. Um, I'm a solutions architect.

[1:00](https://www.youtube.com/watch?v=6NIr_cYPglk&t=60s) Fantastic. All right, so just a quick roadmap of where we're going. We're gonna talk a little bit about Augment Agent. Uh-oh. Do we not have, um...

[1:08](https://www.youtube.com/watch?v=6NIr_cYPglk&t=68s) I see someone pointing. We good now? Okay, fantastic. So we've got, uh, Augment Agent. We're gonna talk a little bit about the Apollo 11 guidance computer, and then we're gonna show you some really interesting things you can do with that code base, uh, and Augment Agent.

[1:21](https://www.youtube.com/watch?v=6NIr_cYPglk&t=81s) So Augment is the, uh, it's the product we're gonna be using today. Um, you do not need your laptop out to follow along with this session. We will do it all in front of your eyes.

[1:29](https://www.youtube.com/watch?v=6NIr_cYPglk&t=89s) But if you want, you can sign up. There's a free trial at augmentcode.com, and, uh, Matt will tell you a little bit about the most important features of Augment Code.

[1:37](https://www.youtube.com/watch?v=6NIr_cYPglk&t=97s) Yeah. Uh, number one is our context engine. So we really identified early on that in order to get high-quality outputs from any of the models, they require high-quality input.

[1:49](https://www.youtube.com/watch?v=6NIr_cYPglk&t=109s) Uh, doing that for, for code bases is not necessarily straightforward. It's not just like text. Um, so, uh, this is something that we've seen in the, in the market.

[2:00](https://www.youtube.com/watch?v=6NIr_cYPglk&t=120s) Uh, a lot of folks think that there's a, a way to do this. We spent two years building a proprietary system that can lift the right knowledge from a code base and pass it over to the models, and we think that results in higher quality outputs and more accurate understanding.

[2:14](https://www.youtube.com/watch?v=6NIr_cYPglk&t=134s) Uh, we're a plugin to existing IDEs. We see in a lot of enterprise that if you've got a ten-year-old Java code base, you're using IntelliJ, you don't wanna have to switch.

[2:23](https://www.youtube.com/watch?v=6NIr_cYPglk&t=143s) Um, and then from day zero, because we were targeting enterprise, we've focused a lot of security capabilities. So we have things that are unique to us versus any other vendor, like customer-managed encryption keys.

[2:34](https://www.youtube.com/watch?v=6NIr_cYPglk&t=154s) We have ISO 42001, which is a new AI ISO standard. Uh, so we really wanted to, to laser in on providing security over what is very important, uh, a very important asset in your code base.

[2:49](https://www.youtube.com/watch?v=6NIr_cYPglk&t=169s) Awesome. And then we've got a couple of tools we'll be referring to today, mainly the chat and agent modes of Augment Code, and when would you use each of those, Matt?

[2:56](https://www.youtube.com/watch?v=6NIr_cYPglk&t=176s) Yeah. Chat is great for kind of simple back-and-forth question and answer, uh, or when you want to leverage a little bit more control over the, the models and you just want to go one turn at a time.

[3:07](https://www.youtube.com/watch?v=6NIr_cYPglk&t=187s) Uh, obviously we see that agents can integrate into other tools, are much more capable of larger, more complex tasks. Um, and then remote agents are great when you actually wanna close the lid on your machine and allow them to continue, continue to run in the background and in parallel.

[3:22](https://www.youtube.com/watch?v=6NIr_cYPglk&t=202s) Yes. We did a workshop on Tuesday that involved a contest component, and I had someone come up to me afterwards, afterwards saying, "I don't understand how the winners were so fast at submitting their solutions," 'cause we had eight or nine problems we were doing.

[3:33](https://www.youtube.com/watch?v=6NIr_cYPglk&t=213s) Oh, okay.

[3:34](https://www.youtube.com/watch?v=6NIr_cYPglk&t=214s) And it's possible some of them were using a remote agent to do some of those tasks in parallel, so it can come in handy for that as well. All right.

[3:40](https://www.youtube.com/watch?v=6NIr_cYPglk&t=220s) So we're gonna be talking today about the Apollo 11, uh, mission in 1969. I think most of us are familiar with this, the first time humans landed on the Moon.

[3:48](https://www.youtube.com/watch?v=6NIr_cYPglk&t=228s) There were three astronauts in that capsule, Neil Armstrong, Buzz Aldrin, and Michael Collins. But sometimes people say there was a fourth astronaut on the Apollo 11 mission. Does anyone know what that astronaut was?

[3:59](https://www.youtube.com/watch?v=6NIr_cYPglk&t=239s) Computer.

[4:00](https://www.youtube.com/watch?v=6NIr_cYPglk&t=240s) Yeah, the, uh, the Apollo Guidance Computer, or the AGC. Uh, and the main things to know about the AGC, so this was used to land the lunar module. If you've ever seen that picture of Margaret Hamilton with, like, that giant stack of papers, uh, with the code on it, that was the source code for the Apollo Guidance

[4:14](https://www.youtube.com/watch?v=6NIr_cYPglk&t=254s) Computer. It was one giant monolithic source file developed over a period of several years at MIT in the 1960s. It was written in Assembly language. Who here has written Assembly at some point in their lives?

[4:25](https://www.youtube.com/watch?v=6NIr_cYPglk&t=265s) Who... Put your hand down if it was in college.

[4:28](https://www.youtube.com/watch?v=6NIr_cYPglk&t=268s) Me.

[4:28](https://www.youtube.com/watch?v=6NIr_cYPglk&t=268s) All right. So keep your hand up if it was in production in some capa-- Yeah, exactly. That's what I thought. Uh, so not a lot of us are gonna be able to look at Assembly code and be able to tell you confidently what it does on first glance.

[4:38](https://www.youtube.com/watch?v=6NIr_cYPglk&t=278s) I certainly can't. I haven't written much Assembly since I was in Computer Systems 201. All right. So in some ways, this is the ultimate legacy code base. It is on GitHub.

[4:47](https://www.youtube.com/watch?v=6NIr_cYPglk&t=287s) You can check it out yourself if you want. It's easy to find. We're gonna try to navigate it well enough to see if we can understand it and land the lunar module ourselves, and Augment Agent is going to help us do that.

[4:57](https://www.youtube.com/watch?v=6NIr_cYPglk&t=297s) So the first thing you wanna do anytime you pop open a large legacy code base is you wanna see if you can get your head around it, right? Someone put a lot of their time and mental energy into putting this code base together, and you've got to catch up with them.

[5:08](https://www.youtube.com/watch?v=6NIr_cYPglk&t=308s) That historically has been a long process. It's been a fraught process. It's been an imprecise process. And AI agents such as Augment Code can help a lot with that.

[5:16](https://www.youtube.com/watch?v=6NIr_cYPglk&t=316s) So let's look at, uh, a specific example, and I'm choosing the 1201 and 1202 program alarms. If you're an Apollo 11 history buff, you know about these because during the final descent onto the surface of the Moon, the astronauts called to Houston and said, "Hey, we're getting this alarm.

[5:31](https://www.youtube.com/watch?v=6NIr_cYPglk&t=331s) It's a 1202." Uh, the, uh, "Give us a reading on the 1202 program alarm." This alarm went off five times, uh, as the lunar module, the Eagle, was making its descent onto the lunar surface, and there was a question for a moment about whether the landing would need to be aborted.

[5:45](https://www.youtube.com/watch?v=6NIr_cYPglk&t=345s) And finally Houston said, "No, you're okay. You can continue." So our question is, could we determine that for ourselves, right? If you were given the Apollo Guidance Computer source code, would you be as confident as Houston was to say, "No, this is not a problem that's going to affect the success or stability of the mission"?

[6:00](https://www.youtube.com/watch?v=6NIr_cYPglk&t=360s) So the way I would do this is I'm gonna pop open... I've got VS Code up here, and I've got, uh, a slightly modified version of the Apollo 11 code base.

[6:08](https://www.youtube.com/watch?v=6NIr_cYPglk&t=368s) Just to orient you, it looks like this. All right, this is, uh, this is their version of Assembly code. It's truly just a bunch of two-word commands saying, "Move this piece of data into this register somewhere."

[6:18](https://www.youtube.com/watch?v=6NIr_cYPglk&t=378s) So it's, it's not fantastically readable. Uh, and even if you did a, like, a grep and looked for 1201 or 1202, it's not gonna tell you what the value of those alarms actually is.

[6:28](https://www.youtube.com/watch?v=6NIr_cYPglk&t=388s) So I can go to Augment Chat, and I can say, um, [keyboard clicking] "What does the 1202 program alarm do?"

[6:37](https://www.youtube.com/watch?v=6NIr_cYPglk&t=397s) And let's see what it tells me. It's generating our response. All right, and so it's gonna take a minute to churn on that. Uh, and it's gonna come back to me with a number of, uh, pieces of information, both from the code base itself, and it will also be able to call out to the web, and it'll

[6:52](https://www.youtube.com/watch?v=6NIr_cYPglk&t=412s) be able to look there. One of the things I think is interesting about using a chat mode like this is, uh, it's kind of similar to calling back to Mission Control in Houston.

[7:00](https://www.youtube.com/watch?v=6NIr_cYPglk&t=420s) Um, and if you were to plug in, like, you know, some MCP servers to this, right, there's a... It gives you an even, uh, an even larger Mission Control element to work with.

[7:08](https://www.youtube.com/watch?v=6NIr_cYPglk&t=428s) Okay, so, uh, it's, it's actually reading this file for us. Uh, uh, so the AGC executive scheduler system runs out of available core sets. All right? And it shows us where that happens.

[7:18](https://www.youtube.com/watch?v=6NIr_cYPglk&t=438s) Look, there's, uh, octal value 1202 right there. It explains the number of registers there are. Uh, it explains the, um, yeah, along with 1201, no VAC area, so it pulled both of these.

[7:28](https://www.youtube.com/watch?v=6NIr_cYPglk&t=448s) And, look, it went out to the web, and it's giving us the context of what actually caused the error. It was an external radar system being left on, and the Apollo 11 computer was smart enough then to offload some low-priority tasks so that it could continue executing mission contr- mission-critical components inside the computer.

[7:44](https://www.youtube.com/watch?v=6NIr_cYPglk&t=464s) That's why they were able to land. Uh, so, yeah, and then there's your little TLDR. 1202 means the computer's trying to do too many things at once and has run out of memory to track all the concurrent jobs.

[7:54](https://www.youtube.com/watch?v=6NIr_cYPglk&t=474s) How long would it have taken you to figure that out on your own reading through that code base, right? I can tell you it would've taken me more than the 30 seconds we've been talking here.

[8:01](https://www.youtube.com/watch?v=6NIr_cYPglk&t=481s) So that's pretty cool to see. All right. The second thing I wanna do is do a little bit of code modernization here. Now, when the lunar module actually landed on the surface, uh, Neil Armstrong used a routine in the lunar landing guidance equations file called P65, and that was kind of like a manual override mode.

[8:20](https://www.youtube.com/watch?v=6NIr_cYPglk&t=500s) They didn't really trust the computer enough to let it land the Eagle all by itself. Neil Armstrong kind of had a thumb on the controls throughout that process. There is also a routine in that file, as I discovered, called P66.

[8:34](https://www.youtube.com/watch?v=6NIr_cYPglk&t=514s) Uh, sorry, he used P66. We're gonna use P65. P65 is full automatic. That's where you just let the lunar module land by itself. It turns out that Augment Agent has a thing called auto mode.

[8:43](https://www.youtube.com/watch?v=6NIr_cYPglk&t=523s) Yes?

[8:44](https://www.youtube.com/watch?v=6NIr_cYPglk&t=524s) Yes.

[8:44](https://www.youtube.com/watch?v=6NIr_cYPglk&t=524s) Uh, I'm gonna show you what that looks like. Uh, so you see down in my chat here, um, I actually was on Augment, uh, on agent mode before. So we could have been in chat mode, but I can also be in agent mode, and this is going to...

[8:56](https://www.youtube.com/watch?v=6NIr_cYPglk&t=536s) If I ask it to write some code for me or to run some code, it's not gonna ask me for permission. It's not gonna wait and have me click on something.

[9:02](https://www.youtube.com/watch?v=6NIr_cYPglk&t=542s) It's just gonna go do it. I could go get a, you know, a cup of coffee, and I could let Augment Agent land on the Moon for me. So what I'm going to do, I've added a couple of files to this code base.

[9:12](https://www.youtube.com/watch?v=6NIr_cYPglk&t=552s) Uh, one is called simulator.py. I wrote a little simulator that expects a file to exist called descent, and it expects a class to exist in that file called LunarDescentGuidance that implements the P65 algorithm.

[9:24](https://www.youtube.com/watch?v=6NIr_cYPglk&t=564s) That file is not written. I'm going to see if Augment Agent can write that file, run the simulator, and land on the Moon without any human assistance whatsoever, just like the actual P65 would've run.

[9:36](https://www.youtube.com/watch?v=6NIr_cYPglk&t=576s) Should we give it a try?

[9:37](https://www.youtube.com/watch?v=6NIr_cYPglk&t=577s) Whoo. Yes.

[9:37](https://www.youtube.com/watch?v=6NIr_cYPglk&t=577s) All right. So this is my favorite prompt to do this. It's just, "Run simulator.py until it succeeds."

[9:46](https://www.youtube.com/watch?v=6NIr_cYPglk&t=586s) Nice.

[9:47](https://www.youtube.com/watch?v=6NIr_cYPglk&t=587s) "Do not change simulator.py." All right. See, that's, that's where it would try to get me, right? Okay, let's see what happens. All right. So what's Augment Agent doing here?

[10:00](https://www.youtube.com/watch?v=6NIr_cYPglk&t=600s) All right, it's gonna run the simulator.py file and work through any issues. So, uh, Matt, any comments you wanna make about, like, how Augment builds its plan for what it wants to run here?

[10:08](https://www.youtube.com/watch?v=6NIr_cYPglk&t=608s) Yeah, so it's gonna use code-based knowledge as a starting point to figure out-

[10:13](https://www.youtube.com/watch?v=6NIr_cYPglk&t=613s) Mm-hmm

[10:13](https://www.youtube.com/watch?v=6NIr_cYPglk&t=613s) ... you know, how it should... what tools it should run, what commands might be important. Um, and so from there, it can start to understand what might be missing.

[10:22](https://www.youtube.com/watch?v=6NIr_cYPglk&t=622s) Mm-hmm.

[10:23](https://www.youtube.com/watch?v=6NIr_cYPglk&t=623s) Um, and then typically, you'll see the agent start to put together the framework of a plan as to how to solve this. So it might go and read individual files and just start to gather a better sense of what it's gonna take to complete the, the task.

[10:36](https://www.youtube.com/watch?v=6NIr_cYPglk&t=636s) So here, it's realizing at this point that the file's missing, and then it's gonna start exploring the code base more generally with our context engine, so it can kind of grok some of that assembly code and start to think about what an implementation would look like.

[10:49](https://www.youtube.com/watch?v=6NIr_cYPglk&t=649s) That's right, and it's actually... Like, it's running little terminal commands for us, right? And it's not waiting for us to intervene here. It's just doing it. All right. So let's map things out.

[10:58](https://www.youtube.com/watch?v=6NIr_cYPglk&t=658s) Uh... Yes. All right. So look, based on... So there's a little test file in here. Oh, it already succeeded. Okay. It, it got ahead of me. So based on the test files, it can understand what the LunarDescentGuidance class should look like, so it created the missing descent.py file.

[11:12](https://www.youtube.com/watch?v=6NIr_cYPglk&t=672s) Let's take a look at that and see. So there you go. So it wrote descent.py. It's a, uh, implementation of the P65 vertical descent guidance. So Augment has indexed this entire code base.

[11:21](https://www.youtube.com/watch?v=6NIr_cYPglk&t=681s) It's able to go look at it. So it found, you know, where it is in the original source code. Uh, and then I gotta tell you, it's easier for me to read Python than it is to read Assembly code, right?

[11:31](https://www.youtube.com/watch?v=6NIr_cYPglk&t=691s) But it's actually laying this out for us. So here's where the position and velocity are. Uh, it's got the desired velocity. It's got the gravity fields. Uh, and then it pulls the routine together, and it, it should actually have a, yeah, an algorithm in here called P65 guidance, uh, that implements this in Python.

[11:46](https://www.youtube.com/watch?v=6NIr_cYPglk&t=706s) And so our final position as it ran this here... Let me go, let me catch up with my, uh, with my chat.

[11:55](https://www.youtube.com/watch?v=6NIr_cYPglk&t=715s) Yeah, and it ran the simulator. Final position, this number of meters, final vertical and horizontal velocity, uh, and you can see that it landed, you know, within our, uh, zero to one meters that we would expect for our final simulation values.

[12:08](https://www.youtube.com/watch?v=6NIr_cYPglk&t=728s) So yay, Augment Agent. [clapping] Good job. [laughs] It landed on the Moon for us. Okay, most of us are not landing on the Moon as part of our day job. So is this a parlor trick?

[12:17](https://www.youtube.com/watch?v=6NIr_cYPglk&t=737s) Is there something we can actually learn here? So this is what I would take back to a legacy code base of mine based on what we've seen today. There's three basic steps.

[12:25](https://www.youtube.com/watch?v=6NIr_cYPglk&t=745s) Number one, anytime you pull this open, you're gonna try to use the agent to help you understand on your own what's going on in that code base. So Augment Agent will index it for you.

[12:33](https://www.youtube.com/watch?v=6NIr_cYPglk&t=753s) You can ask questions in chat. You're gonna be asking questions like, "What does this code base actually do?" Right? "What does this piece of the code, what does file XYZ do for me?

[12:41](https://www.youtube.com/watch?v=6NIr_cYPglk&t=761s) Are there style or convention things going on here that I should be aware of?" Uh, and then you can start writing some tests. So sometimes people ask, like, you know, "If I am not sure I fully understand this code, am I gonna know if the new code that I create is actually correct?"

[12:55](https://www.youtube.com/watch?v=6NIr_cYPglk&t=775s) So I think a blend of agent and chat mode are gonna help you out a lot here. Use chat mode to predict what you think the code should do.

[13:00](https://www.youtube.com/watch?v=6NIr_cYPglk&t=780s) So in the case of the P65 algorithm, you know, tell me what I think should happen when I run this lunar descent given these input parameters, and then have the agent mode write some tests to check that behavior.

[13:10](https://www.youtube.com/watch?v=6NIr_cYPglk&t=790s) It's not always gonna get it right. I had a case where it was working with the scheduler, and it couldn't decide for itself whether priority level zero was the highest level or lowest level in the system, and you could convince it either way.

[13:21](https://www.youtube.com/watch?v=6NIr_cYPglk&t=801s) Like, it's a classic thing an agent would struggle with. So take the time to go, you know, read yourself, right? Have it surface those pieces of the code for you, and then, you know, you're an engineer.

[13:30](https://www.youtube.com/watch?v=6NIr_cYPglk&t=810s) You can in- apply your human ingenuity to it. And then modernize. Start converting small portions of the code in modular fashion to the desired language or, you know, style that you want and apply those same tests to make sure that you're not getting far afield from what the actual functionality of the code should be.

[13:46](https://www.youtube.com/watch?v=6NIr_cYPglk&t=826s) And that is not just a strategy for success landing the Apollo 11 guidance computer on the Moon, but for working with your code as well. All right. Once again, you can try Augment Agent yourself, uh, for free at augmentcode.com.

[13:59](https://www.youtube.com/watch?v=6NIr_cYPglk&t=839s) Uh, bring your gnarliest legacy code bases and refactoring projects. I forget how many lines of code are in the Apollo guidance computer repo. It's thousands. Um, I mean, that's reasonable for this, right?

[14:10](https://www.youtube.com/watch?v=6NIr_cYPglk&t=850s) Yeah. That's pretty small fry-

[14:11](https://www.youtube.com/watch?v=6NIr_cYPglk&t=851s) Yeah

[14:11](https://www.youtube.com/watch?v=6NIr_cYPglk&t=851s) ... when it comes to, like, enterprise projects these days. So, you know, the real world equivalent of this kind of thing might be, like, I've got a Java 8 project.

[14:18](https://www.youtube.com/watch?v=6NIr_cYPglk&t=858s) I wanna go to Java 17. Uh, it's really tedious, toilsome. How do I pass some of that over to, to AI?

[14:25](https://www.youtube.com/watch?v=6NIr_cYPglk&t=865s) Yep.

[14:25](https://www.youtube.com/watch?v=6NIr_cYPglk&t=865s) That's the, that's the, like, real world equivalent, yeah.

[14:27](https://www.youtube.com/watch?v=6NIr_cYPglk&t=867s) That's right. And as you can see, it's pretty fast too. Um, and you can bring your greenfield projects. There's no shame in that, but, uh, the legacy ones I think are a little bit more fun.

[14:35](https://www.youtube.com/watch?v=6NIr_cYPglk&t=875s) That's all we've got. Yes, sir. What about things like, uh, checking for dependencies across, like, a large code base? It loves to do that. Yeah. And it can actually go back in and- Yes, it can.

[14:48](https://www.youtube.com/watch?v=6NIr_cYPglk&t=888s) And you actually s- in 20 seconds, you actually saw a little bit of that here, right? Where it went through and, like, there were some missing files. It tried to run Python and said, "Oops, it's not installed.

[14:56](https://www.youtube.com/watch?v=6NIr_cYPglk&t=896s) I'm gonna use Python 3 instead," right? There's... It's happy to do that. In 12 seconds, go ahead, Drew. What you showed was test-driven development effectively. Yes. Like, did this move, move the needle on whether that's a recommended practice or...?

[15:08](https://www.youtube.com/watch?v=6NIr_cYPglk&t=908s) Yeah. Agents love to reason and iterate, so any way they, they can check their own result is very helpful. So tests are good for that.

[15:15](https://www.youtube.com/watch?v=6NIr_cYPglk&t=915s) That's a great question. We are out of time. Thanks, everyone. We appreciate you. [upbeat music]
