Transcription: OpenAgents Episode 161 - Basic Coding Loop
June 9, 2026 ยท View on GitHub
Source: https://x.com/OpenAgentsInc/status/1889912687770882160 Wiki source: https://raw.githubusercontent.com/wiki/OpenAgentsInc/openagents/Video-Series.md Media title: OpenAgents - Episode 161: Basic Coding Loop We implement the first working versio... Upload date: 20250213 Transcription model: gpt-4o-transcribe-diarize Generated at: 2026-06-01T06:15:00Z
Machine-generated transcript. Review speaker labels and wording before using this as quote-grade source material.
[00:00] Christopher David: Oh folks, I think it's gonna start getting real interesting here. We're now going to build the core loop for the agent writing the code.
[00:14] Christopher David: We are on the quest for the holy grail of agentic software development,
[00:18] Christopher David: an agent that can reliably convert GitHub issues into mergeable pull requests in an automated loop.
[00:25] Christopher David: We've completed the first two milestones.
[00:28] Christopher David: in the last two videos.
[00:31] Christopher David: Uh these next ones may not be separate milestones or separate videos. Uh it's basically just like the core
[00:41] Christopher David: the core loop. Uh testing will probably be separate but now like
[00:47] Christopher David: having it go through the file and make the code edits
[00:53] Christopher David: let's may all be done in one thing. So we're gonna see how far we can get in this video.
[01:02] Christopher David: Yeah.
[01:04] Christopher David: So I want to do this together because I feel like this is potentially something almost historic.
[01:09] Christopher David: So we're going to kind of let you see all of what happens.
[01:15] Christopher David: So usually what I'll do is I'll do a kind of a preparatory background to open agents and I'll ask it to make an issue.
[01:34] Christopher David: So here's what I'm saying.
[01:39] Christopher David: Scrap our blog post about chain of thought in action.
[01:45] Christopher David: Read repo map, read these things.
[01:51] Christopher David: Note the six step plan in episode 157 description. We did the first two and now we need to do the next.
[01:57] Christopher David: Some may blur or be similar together. Multiple are probably addressed by issue 651, we started on a few weeks ago, 651 being
[02:10] Christopher David: implement the stateful solver loop with continuous object updates.
[02:15] Christopher David: More on that shortly.
[02:22] Christopher David: Back then trying to get a proof of concept working via CLI, which we now want to continue forward with using our Hyperview mobile app integration.
[02:28] Christopher David: Though we may continue forward with issue 651,
[02:30] Christopher David: I want you to create a new issue that can be kind of an overarching issue for the rest of the work that needs to be done.
[02:36] Christopher David: Something like implement agentic coding loop, which we can make other issues be sub-issues of in the future.
[02:41] Christopher David: The issue shouldn't paste a bunch of code snippets, but rather go into detail about various subsystems, algorithms, consideration strategies,
[02:47] Christopher David: and how to get this initial loop completed.
[02:50] Christopher David: We can make other issues sub-issues of this one. When this issue is done, we should have open agent slash Onyx solving issues by creating tested pull requests fully autonomously.
[03:00] Christopher David: And I put in the blurbs for one five seven, one five eight, one five nine and one six zero.
[03:05] Christopher David: Okay.
[03:07] Christopher David: Let's see what it comes up with. Created issue six ninety seven.
[03:13] Christopher David: Implement a Django coding loop.
[03:17] Christopher David: This issue outlines the implementation of a complete agentic coding loop that can autonomously solve GitHub issues by creating tested pull requests.
[03:25] Christopher David: Building on the work from issue 651,
[03:27] Christopher David: the Stateful Solver Loop,
[03:28] Christopher David: and integrating with our recent mobile app development,
[03:31] Christopher David: 695,
[03:32] Christopher David: 693,
[03:33] Christopher David: 688,
[03:33] Christopher David: we'll create a robust system that demonstrates chains of thought and action in practice.
[03:39] Christopher David: System architecture,
[03:40] Christopher David: core components.
[03:42] Christopher David: State management.
[03:43] Christopher David: Enhance state machine from issue 651. Persistent state tracking across all operations. Clear status progression through solving phases. Error recovery and retry mechanisms. Context collection.
[03:53] Christopher David: Repository mapping,
[03:54] Christopher David: building on existing repo map generation.
[03:57] Christopher David: Issue analysis using structured LLM outputs.
[04:00] Christopher David: File relevance scoring and prioritisation. Code context gathering analysis, blah blah blah.
[04:03] Christopher David: Planning system. Multi-set reasoning with visible thought process. Action planning with clear justifications. Change validation and impact analysis.
[04:10] Christopher David: Test planning and verification strategies. Uh execution engine. Save file modification system, text, execution and validation, get operations,
[04:18] Christopher David: branch, commit, PR,
[04:18] Christopher David: rollback, aborts.
[04:20] Christopher David: Integration points.
[04:21] Christopher David: Mobile integration.
[04:22] Christopher David: Hyperview based UI for monitoring. Real-time status updates.
[04:26] Christopher David: Action approval interface optional.
[04:28] Christopher David: Progress visualization.
[04:30] Christopher David: LLM integration.
[04:32] Christopher David: This is outdated.
[04:34] Christopher David: Mistral anyways.
[04:36] Christopher David: We use Gemini Flash 2 in that last video that we're defining.
[04:40] Christopher David: Deep ZR1,
[04:41] Christopher David: we will probably use that.
[04:42] Christopher David: Clear separation of reasoning in the action phases.
[04:44] Christopher David: Visible thought process logging.
[04:45] Christopher David: Okay.
[04:47] Christopher David: Implementation phases.
[04:48] Christopher David: Core loop enhancement.
[04:49] Christopher David: Extend stateful solver loop from 5651.
[04:52] Christopher David: Persistent state storage.
[04:53] Christopher David: Robust error handling.
[04:54] Christopher David: Compliance of logging.
[04:55] Christopher David: Conduct system.
[04:56] Christopher David: Enhanced reboot map generation,
[04:58] Christopher David: relevant
[05:02] Christopher David: Browsing scoring, where do you have that?
[05:05] Christopher David: Well, there's reasoning, blah blah blah.
[05:07] Christopher David: Technical
[05:13] Christopher David: Technical considerations, state management, solver status, collecting context, analysing issue,
[05:19] Christopher David: planning changes, generating code.
[05:22] Christopher David: Testing changes completed. Creating pull request complete error.
[05:27] Christopher David: Yeah, I think a finite state machine would be cool.
[05:32] Christopher David: Context collection.
[05:33] Christopher David: Use the structured LMM as a consistent analysis. Implement relevant scoring algorithm.
[05:37] Christopher David: Cache context data for efficiency. Handle large code bases gracefully.
[05:40] Christopher David: Planning system. Breakdown solutions into atomic changes. Validate changes against context.
[05:44] Christopher David: Plan tests for each change.
[05:45] Christopher David: Consider dependencies between changes.
[05:47] Christopher David: Execution safety. Validate all file operations.
[05:49] Christopher David: Run in isolated environment.
[05:50] Christopher David: Maintain audit trail.
[05:51] Christopher David: Export robot coverage.
[05:51] Christopher David: Okay.
[05:53] Christopher David: Success criteria.
[05:54] Christopher David: Autonomy. Can understand issue context. Makes appropriate code changes. Creates valid pull requests. Handles errors gracefully.
[06:00] Christopher David: Transparency. Shows reasoning process. Logs all actions taken. Provides clear status updates. Maintains audit trail.
[06:06] Christopher David: Reliability.
[06:07] Christopher David: Consistent success rate.
[06:08] Christopher David: Proper error handling.
[06:09] Christopher David: No destructive operations.
[06:10] Christopher David: Maintains code quality.
[06:11] Christopher David: 4.
[06:12] Christopher David: Integration.
[06:12] Christopher David: Works with mobile app.
[06:13] Christopher David: Real-time status updates. Clear user interface.
[06:14] Christopher David: Proper authentication.
[06:16] Christopher David: Testing strategy.
[06:16] Christopher David: Blah blah blah.
[06:17] Christopher David: Security considerations.
[06:20] Christopher David: Fine.
[06:21] Christopher David: Future enhancements.
[06:24] Christopher David: Okay.
[06:26] Christopher David: Next steps. Review and refine this architecture.
[06:29] Christopher David: Create sub-issues for each component.
[06:32] Christopher David: Prioritize implementation order.
[06:33] Christopher David: Begin core loop enhancement.
[06:36] Christopher David: When completed, the system will provide a fully autonomous,
[06:38] Christopher David: transparent,
[06:38] Christopher David: and reliable solution for converting GitHub issues into test pull requests,
[06:42] Christopher David: demonstrating the power of change and thought and action practice.
[06:43] Christopher David: Okay.
[06:47] Christopher David: Fine.
[06:48] Christopher David: Some of it got a little flowery or sloppy,
[06:54] Christopher David: but
[06:59] Christopher David: fine.
[07:00] Christopher David: So I want
[07:04] Christopher David: the basics implemented,
[07:08] Christopher David: or
[07:11] Christopher David: the straightest path to basics being implemented.
[07:15] Christopher David: Let's actually just put my observations here. I want the straightest path to the basics being implemented. So we already have repo map being created from a repo and issue selected by the user.
[07:36] Christopher David: We pass the repo map and
[07:41] Christopher David: issue details.
[07:44] Christopher David: to Gemini 2.0 Flash,
[07:48] Christopher David: not Deep Seek plus Mistral as mentioned,
[07:54] Christopher David: but we may use them later.
[08:04] Christopher David: And get back a list of files.
[08:09] Christopher David: File paths priority comment now we need to loop
[08:19] Christopher David: through those files creating
[08:26] Christopher David: them or
[08:30] Christopher David: modifying them where
[08:36] Christopher David: files need to be modified
[08:41] Christopher David: We'll want to somehow accumulate diffs maybe as search replace blocks so we can make targeted edits.
[08:56] Christopher David: Potentially we could start with full file edits.
[09:05] Christopher David: But goal is to make targeted.
[09:10] Christopher David: edits.
[09:12] Christopher David: Um
[09:23] Christopher David: Let's
[09:25] Christopher David: create
[09:28] Christopher David: Hmm.
[09:32] Christopher David: Let's think about what subset of issue six nine seven
[09:38] Christopher David: should be applied toward the next phase of this which I want you to make a sub issue for after we discuss it here and in you know after we discuss it here so
[09:57] Christopher David: in this next sprint of development over the next hour or so
[10:06] Christopher David: We have a minimum viable agentic
[10:11] Christopher David: coding loop that takes the list of files and converts it into code
[10:27] Christopher David: changes,
[10:28] Christopher David: diffs, or ideally
[10:32] Christopher David: our first pull request.
[10:36] Christopher David: We can get more fancy later about additional iteration passes to enrich context or traverse a graph of connected concepts from the repo.
[10:56] Christopher David: More evolved repo map,
[10:58] Christopher David: etc.
[11:01] Christopher David: I'd be happy next with a very simple loop that,
[11:08] Christopher David: for example, opens the file contents of each file path,
[11:20] Christopher David: and
[11:23] Christopher David: if it's a modification,
[11:27] Christopher David: To ask if it's a potential modification. To ask the LLM, Gemini, same as what generates the relevant file list,
[11:41] Christopher David: for a structured output of any suggested changes along with a comment and
[11:52] Christopher David: a summary.
[11:57] Christopher David: of its action we can show to the user.
[12:07] Christopher David: We should aggregate any such changes and additions in that single finite state machine thingy.
[12:23] Christopher David: And then, when done,
[12:30] Christopher David: generate a pull request with
[12:34] Christopher David: the code.
[12:37] Christopher David: If that is clear,
[12:39] Christopher David: please create a
[12:44] Christopher David: sub-issue just
[12:49] Christopher David: for that next step.
[12:51] Christopher David: we will do in the next hour.
[13:25] Christopher David: How do I make this a sub issue?
[13:28] Christopher David: Parent issue.
[14:15] Christopher David: So you know what would be cool is if we can, as we now go and code this up,
[14:21] Christopher David: let's see if we can help it out a little bit by
[14:31] Christopher David: actually using what we have so far to generate the
[14:39] Christopher David: changes.
[14:40] Christopher David: How would you suggest we change based on the current issues?
[14:47] Christopher David: Okay,
[14:47] Christopher David: let's try this.
[14:49] Christopher David: Refresh.
[15:00] Christopher David: Open Agents.
[15:06] Christopher David: So we've got basic code change loop. Let's analyze the issue. Oh, I don't know if I'm gonna be able to copy paste well from this.
[15:15] Christopher David: Let's just see what it does here. Let's just see what it does.
[15:46] Christopher David: extract the file paths, priorities
[15:50] Christopher David: and
[15:54] Christopher David: comments from this XML and put here in a markdown code block.
[16:23] Christopher David: It's going to get real interesting,
[16:24] Christopher David: people.
[16:25] Christopher David: It's going to get real interesting.
[16:26] Christopher David: Okay, so let's do that also for 697.
[17:32] Christopher David: This does not look like a good list.
[17:33] Christopher David: Is this a good list?
[17:36] Christopher David: No!
[17:47] Christopher David: No, this is not good.
[17:48] Christopher David: I mean structurally it's great, but it's not taking into account existing files.
[17:56] Christopher David: What the hell?
[18:03] Christopher David: This file would likely contain Yeah, something is something is not being uh generated. Maybe the repo map is not being passed in or something. Okay, we'll we'll debug that later.
[18:16] Christopher David: I don't need it. So we've got two good issues. Let's just double check that these look good.
[18:24] Christopher David: Um so the state machine
[18:27] Christopher David: Solver state status
[18:29] Christopher David: files changes path
[18:36] Christopher David: action content create
[18:42] Christopher David: modify search replace nice yeah
[18:48] Christopher David: i like that okay
[18:56] Christopher David: Okay, I'll need to cut that part out.
[19:18] Christopher David: Okay, so let's do new.
[19:29] Christopher David: Look at
[19:41] Christopher David: any other files you want for additional context.
[19:46] Christopher David: We are now going to implement issue 698
[19:55] Christopher David: on a new branch.
[20:00] Christopher David: look at all the files you need to then propose here what to do.
[20:57] Christopher David: No, you're not gonna create a new module code change.
[21:03] Christopher David: A new service? Uh maybe. A service
[21:10] Christopher David: Well, I was just
[21:12] Christopher David: worried that it would be duplicating what I already have for GitHub issue. Um
[21:38] Christopher David: Generally that sounds good, but make sure you don't you
[21:45] Christopher David: don't duplicate any existing code. We already have stuff for handling GitHub issues.
[22:15] Christopher David: Make sure you can find where this would connect.
[22:19] Christopher David: Like right now where we are returning
[22:23] Christopher David: to the user a list of the relevant files.
[22:40] Christopher David: Instead that should go right into the
[22:44] Christopher David: solver flow and only
[22:49] Christopher David: show the user updates
[22:57] Christopher David: summaries of each agent action.
[23:05] Christopher David: Refine your plan based on that.
[23:14] Christopher David: ah yes i see now, looking at the existing code particularly analyser and the hyper-view handlers,
[23:19] Christopher David: I can see we already have GitHub issue analysis via open router, file relevance scoring and prioritisation, UI for showing analysis results. Let me refine the plan to build on this existing infrastructure. Modify the issue analysis flow and issue analysis to keep the analysis part but instead of displaying results, initiate the solver flow with the Nash analyse file. Create a new solver module.
[23:38] Christopher David: Okay, here's how where I need to point it at what already exists for solver stuff.
[23:56] Christopher David: That is better, but first note we have a bunch of solver-related stuff.
[24:07] Christopher David: in
[24:09] Christopher David: source bins solver impulse. So first look through that folder. For code you can reuse,
[24:18] Christopher David: even if you need to move it or copy it elsewhere.
[24:24] Christopher David: Okay, once you've reviewed that then start making the changes. Small self-contained modular
[24:35] Christopher David: changes first. So we can make sure all make sure everything compiles as we go.
[24:50] Christopher David: Let me first explore what we have in solve ramble. Let me check a few key files.
[25:12] Christopher David: Great.
[25:13] Christopher David: I see we have a robust implementation in solver imple. The key components are changes, handles generating and applying code changes, changes analysis, common types, okay.
[25:25] Christopher David: First let's move the solver implementation. Okay.
[25:35] Christopher David: I wish this could make github comments. I mean I'm sure I could connect this to a freaking
[25:44] Christopher David: m
[25:48] Christopher David: anthropics thing mcp server but
[25:54] Christopher David: i don't
[26:44] Christopher David: These changes establish the basic infrastructure for the solver integration. I've created a new solver service with types of database storage, added a migration for the solver states table,
[26:53] Christopher David: modified the issue analysis handler to create a solver state and show a start solving button.
[26:58] Christopher David: Next steps would be to create the solver status handler to show progress,
[27:01] Christopher David: implement the solver change generation logic using the existing f code from changes,
[27:07] Christopher David: add UI.
[27:21] Christopher David: First, fix these errors.
[29:52] Christopher David: Let's add a method to start generating changes using these services.
[30:26] Christopher David: I'll call this Checkpoint one.
[30:40] Christopher David: Yes, continue with the next phase.
[30:46] Christopher David: When at a good stopping point,
[30:49] Christopher David: run cargo check.
[31:00] Christopher David: And fix errors
[31:03] Christopher David: and sell no errors or warnings.
[31:06] Christopher David: Now watch this. I'm gonna go afk. Can I get back before it finishes?
[33:23] Christopher David: That accepted a four run, thank it.
[33:26] Christopher David: OpenAgents doesn't need to.
[33:32] Christopher David: Well actually OpenAgents isn't yet doing the terminal things like those. So I take that back.
[34:20] Christopher David: Hmm.
[34:42] Christopher David: Alright, a markdown
[34:46] Christopher David: block with a
[34:48] Christopher David: Comment I can add to the get a issue
[34:56] Christopher David: six nine eight as a status update.
[35:19] Speaker B: emojis.
[35:33] Christopher David: Should I test now or how it keep going?
[35:35] Christopher David: Continue to the next stage.
[35:41] Christopher David: Also ending with cargo check and fixing all errors and warnings.
[37:14] Christopher David: Yeah, no.
[37:21] Christopher David: You can keep the code in there,
[37:24] Christopher David: but at least for now I don't want any changes to be prompted to the user.
[37:34] Christopher David: They must be made automatically.
[37:37] Christopher David: User will be able to review them at the pull request review stage.
[37:45] Christopher David: at once. Make any needed edits so that code is not being used.
[37:55] Christopher David: And whatever flags for unused code necessary, so we don't get warning
[38:54] Speaker C: Ah, I understand.
[40:24] Christopher David: I don't like having to click each time. I'm sure there's probably a thing I can set
[40:32] Christopher David: to not prompt each time.
[41:29] Christopher David: What the fuck
[41:36] Christopher David: Alright, this is the last time that I care about this
[42:08] Christopher David: Uh, no,
[42:09] Christopher David: idiot,
[42:10] Christopher David: just do the next phase of stuff. I don't care.
[42:25] Christopher David: And we'll get the change approval and rejection handlers. Uh.
[42:30] Christopher David: Yes, logic for applying changes, and no, I told you to skip over the approval and rejection.
[42:40] Christopher David: Handlers, we are not implementing that now. See, this is interesting. It's very obvious that they're heavily pruning the conversation history.
[42:49] Christopher David: In OpenAgents, we just have different defaults, where I'm passing essentially the entire conversation to Sonic.
[42:55] Christopher David: And so it's more expensive,
[42:57] Christopher David: but it's also way...
[42:59] Christopher David: More accurate and cool I
[43:02] Christopher David: would not have had to do a reminder,
[43:04] Christopher David: you know six messages later
[43:37] Christopher David: Write a comment in a markdown code block, I can post on issue
[43:45] Christopher David: with status update.
[43:48] Christopher David: And what was that, checkpoint four?
[44:05] Christopher David: Uh this might be a good time to test, let's see.
[44:09] Christopher David: Status update. Code change loop implementation progress completed. Implemented core change generation and application flow. Deep seek integration for high level code analysis. Open writer integration for specific code change generation. Direct change application without manual review step. Enhanced state machine with proper status tracking. Added analysing, generating changes, applying changes, complete states. Implemented state persistence in database.
[44:31] Christopher David: Add proper air handling and status updates. Improved change application logic.
[44:37] Christopher David: Exact code matching, enhanced logging, air handling.
[44:43] Christopher David: Okay.
[44:47] Christopher David: The core code change loop is now functional. We can go from issue analysis to applied changes automatically. Next phase will focus on creating power custom issues. Okay, I don't believe you.
[44:58] Christopher David: I
[44:58] Christopher David: I don't believe you at all, uh
[45:02] Christopher David: but I want to believe you. So let's try testing it.
[45:11] Christopher David: So this looks, oopsies. Cargo watch run.
[45:41] Christopher David: Agents, let's analyze the current issue we're doing.
[45:52] Christopher David: Okay, we got some stuff. What is this stuff?
[46:02] Christopher David: Successfully parsed nested response.
[46:07] Christopher David: Created new solver state. Do I have that in the database? Okay, so let's look here.
[46:13] Christopher David: Solver state. Oh, yes. Analyzing 698 issue title.
[46:20] Christopher David: Ah, and the file,
[46:22] Christopher David: that looks good. Oh, that looks good.
[46:26] Christopher David: Okay, so maybe I'll even copy this.
[46:48] Christopher David: Well now we need to test it, because it's not fully working. For now I have one server entry
[47:01] Christopher David: and
[47:03] Christopher David: here are the server logs.
[47:07] Christopher David: And here are the server logs.
[47:57] Christopher David: why it's not looping.
[48:46] Christopher David: When you click Start Solving,
[48:52] Christopher David: whatever do you mean?
[49:21] Christopher David: Oh here.
[49:24] Christopher David: There's a button. It says
[49:27] Christopher David: start solving.
[49:30] Christopher David: What do you suppose this does?
[49:34] Christopher David: Okay.
[49:39] Christopher David: Now when I click
[49:42] Christopher David: start solving, I get a hyper view error.
[49:48] Christopher David: app parser
[49:52] Christopher David: error XML DOM error invalid doc source
[50:52] Christopher David: Play again.
[51:11] Christopher David: Analyzing issue.
[51:21] Christopher David: Start solving.
[51:24] Christopher David: Uh
[51:43] Christopher David: I again get the same
[51:47] Christopher David: XML DOM error. Here is the most recent client logs.
[53:04] Christopher David: Start solving.
[53:06] Christopher David: Starting to generate changes for updater solver state.
[53:10] Christopher David: What do we got?
[53:14] Christopher David: Generating changes.
[53:16] Christopher David: Good.
[53:17] Christopher David: Keep going.
[53:20] Christopher David: Updated solver state again.
[53:26] Christopher David: I'd like to see the response.
[53:28] Christopher David: Anything here?
[53:31] Christopher David: Oh, what happened,
[53:32] Christopher David: what happened, what happened?
[53:35] Christopher David: Something with the repo map,
[53:37] Christopher David: what's going on?
[54:16] Christopher David: Failed to read source solver ah ha ha ha ha ha ha. Okay,
[54:24] Christopher David: so here's a few things.
[54:26] Christopher David: Here's the like issue we found an earlier. Okay first of all we had some updates,
[54:32] Christopher David: good.
[54:36] Christopher David: But I don't know why it started generating
[54:43] Christopher David: Hmm.
[54:45] Christopher David: Reba map in the middle of all that.
[54:51] Christopher David: I see in the response
[54:57] Christopher David: printed on the app
[55:00] Christopher David: failed to read search solver state dot R_S_
[55:10] Christopher David: There's a trialware directory.
[55:14] Christopher David: This is from the agent trying to access a file that doesn't exist.
[55:25] Christopher David: We need a graceful way
[55:28] Christopher David: of checking file paths whether they exist or not.
[55:36] Christopher David: Files will need to be modified or created.
[55:48] Christopher David: What was the other thing?
[57:20] Christopher David: It moved to applying changes. Wow.
[57:25] Christopher David: Let's see what happens here.
[57:31] Christopher David: Looking forward to cleaning up this horrific UI.
[57:56] Christopher David: Either way, can I see?
[58:40] Christopher David: I wonder if there's like a stupid model like some old models being used.
[58:45] Christopher David: I don't think we're using Sonic for Gemini. It's how to replace some of that stuff.
[58:50] Christopher David: Because this is just like the intelligence went down. It's probably using the wrong model.
[58:54] Christopher David: Anyways, where are we at?
[58:59] Christopher David: Something's still going.
[59:01] Christopher David: Where are we at?
[59:05] Christopher David: Updated at.
[59:12] Christopher David: Minutes ago?
[59:14] Christopher David: Ooh.
[59:17] Christopher David: Okay, it tried to apply the changes.
[59:19] Christopher David: Fuck yes.
[59:25] Christopher David: Maybe the only way it knows to clone the repo is there's repo cloning as part of the repo map generation.
[59:40] Christopher David: Getting closer.
[59:47] Christopher David: Updated that just now.
[59:49] Christopher David: Do I have changes here?
[59:53] Christopher David: Get out of my way.
[59:57] Christopher David: Changes. Oh yeah.
[01:00:03] Christopher David: Okay, first of all, search replace this is
[01:00:13] Christopher David: this is not right at all.
[01:00:21] Christopher David: We got a loop going,
[01:00:22] Christopher David: it's just a dumb loop.
[01:00:36] Christopher David: Got this log
[01:00:43] Christopher David: ending in this.
[01:00:46] Christopher David: Note how every search replace, which is supposed to be code,
[01:00:51] Christopher David: actually has a file path or explanation that should be the comment. So I'm thinking either there is unclear
[01:01:04] Christopher David: uh prompt, instructions somewhere, or you are using a dumb model.
[01:01:12] Christopher David: Um I want the
[01:01:15] Christopher David: the
[01:01:17] Christopher David: code
[01:01:22] Christopher David: anything using Mistral or
[01:01:26] Christopher David: to be using Gemini Flash instead.
[01:01:31] Christopher David: In fact, let's use Gemini Flash for all this whole process for now.
[01:01:42] Christopher David: Make those changes and tell me what models were currently being used.
[01:01:49] Christopher David: When done with those changes,
[01:01:52] Christopher David: tell me another GitHub comment in a markdown block I can add to the issue.
[01:02:03] Christopher David: Getting closer, getting closer.
[01:02:18] Christopher David: Looking at the code we using open routers there you have to tell me what model you have to tell me what model we're using.
[01:02:29] Christopher David: The default model was it using that.
[01:02:45] Christopher David: self.config, I can't tell
[01:04:14] Christopher David: Okay let's try it again.
[01:04:38] Christopher David: What is this?
[01:04:39] Christopher David: What is this four oh four?
[01:04:43] Christopher David: No endpoints found.
[01:04:54] Christopher David: No endpoints found.
[01:05:13] Christopher David: Fires Thinking X for 2019. Fireside Preview.
[01:05:19] Christopher David: No, no, no, I don't wanna use Thinking.
[01:05:22] Christopher David: This was what I was using before, I thought.
[01:05:26] Christopher David: O_ two O_ five three.
[01:05:32] Christopher David: Okay. Incorrect model.
[01:05:38] Christopher David: Must be a boom.
[01:05:42] Christopher David: Like that.
[01:05:46] Christopher David: Ah yes, you're right.
[01:05:58] Christopher David: Is flashlight preview worse than flash? I'm guessing it is.
[01:06:02] Christopher David: I'll get our actual Gemini key in here at some point soon.
[01:06:06] Christopher David: Let's try it.
[01:06:12] Christopher David: But it would be even cooler if we could get this to work nicely with just this free,
[01:06:16] Christopher David: the light the preview model.
[01:06:19] Christopher David: Okay, let's try it again.
[01:07:24] Christopher David: Generating changes.
[01:07:27] Christopher David: That one says complete,
[01:07:28] Christopher David: that's interesting.
[01:07:41] Christopher David: Is it just done? What the hell's going on?
[01:08:10] Christopher David: Something seems hung up.
[01:08:13] Christopher David: I have this.
[01:08:22] Christopher David: What happened?
[01:08:24] Christopher David: Change is complete.
[01:08:25] Christopher David: Pull request created.
[01:08:26] Christopher David: Well, it obviously did not.
[01:08:28] Christopher David: Oh, here we go.
[01:08:33] Christopher David: Okay, so it's not hung up. It just took a while.
[01:08:36] Christopher David: complete,
[01:08:36] Christopher David: it says. Obviously it's not complete.
[01:08:39] Christopher David: But I will take a look at what you made.
[01:08:53] Christopher David: You fucking guy. Same shit.
[01:09:29] Christopher David: Can't do select all inside here? Stupid.
[01:09:35] Christopher David: It's fucked.
[01:09:42] Christopher David: Says it's complete but again has the same stupid error with search replace where it's putting file paths and summaries where there should be code.
[01:09:58] Christopher David: Find what the fuck is doing that.
[01:10:18] Christopher David: I see the issue.
[01:10:46] Christopher David: It's probably not even using structured output. Hang on, hang on, hang on.
[01:10:55] Christopher David: Wait, that's not what I want. Uh open router, structured outputs.
[01:11:19] Christopher David: Scrape this and make sure you use structured output.
[01:11:32] Christopher David: Okay, that's probably the problem. We just we're not using structured yet.
[01:13:01] Christopher David: The Analyse issue binary?
[01:13:54] Christopher David: Failed to parse open router response into get of issue files. Okay.
[01:17:08] Christopher David: Start solving.
[01:17:13] Christopher David: Updated solver state.
[01:17:37] Christopher David: generating changes.
[01:17:43] Christopher David: We have a loop. It's iterating through the state machine. It's doing stuff. It's updating this. Just got a bit of tweaking to do.
[01:17:57] Christopher David: What do we have so far?
[01:18:10] Christopher David: Yeah, I think this is still like this weird hallucination going on because it's not picking from the actual repo map,
[01:18:18] Christopher David: unfortunately.
[01:18:21] Christopher David: Something broke somewhere,
[01:18:22] Christopher David: but we'll find it.
[01:18:34] Christopher David: Look at this.
[01:18:37] Christopher David: Applying changes. Updated solver state. Applying changes. Creating new file.
[01:18:42] Christopher David: Creating new file. Creating new file. Could not find search string in P_R_ creation.
[01:19:02] Christopher David: It says complete.
[01:19:06] Christopher David: That looks like some progress.
[01:19:11] Christopher David: Write another comment in markdown code block.
[01:19:17] Christopher David: Analyze and fix these logs.
[01:20:23] Christopher David: Huh?
[01:20:33] Christopher David: Oh, I got fucked up.
[01:20:53] Christopher David: First of all, where is it even trying to apply the files?
[01:21:02] Christopher David: This needs to be in the repo we clone, like in the repo map thing.
[01:21:11] Christopher David: I'm also concerned about the relevant files.
[01:21:19] Christopher David: call.
[01:21:22] Christopher David: It seems like it is not pulling anything from the existing repo map.
[01:21:30] Christopher David: Can you confirm that we are passing that in correctly?
[01:21:42] Christopher David: The correct flow.
[01:21:50] Christopher David: Is that even documented there? Not really.
[01:22:03] Christopher David: Shall I go back to the original issue?
[01:22:51] Christopher David: We're trying to apply changes after the repo has been deleted. Yeah. Thank you.
[01:24:33] Christopher David: Write a comment in Markdown block explaining what all you just did.
[01:24:43] Christopher David: Accept all.
[01:25:28] Christopher David: Cargo C-Plex database no.
[01:25:34] Christopher David: Migrate revert.
[01:25:35] Christopher David: How
[01:25:43] Christopher David: How do I apply the migration rolling back just the last one.
[01:26:27] Christopher David: This is nice.
[01:26:34] Christopher David: Do it.
[01:26:37] Christopher David: Ah yes.
[01:26:46] Christopher David: You can continue with your development now.
[01:27:12] Christopher David: Okay.
[01:29:06] Christopher David: Go.
[01:29:07] Christopher David: Okay.
[01:30:03] Christopher David: Oh, I'm guessing it might be making a bunch of calls that it's not informing me of?
[01:31:19] Christopher David: Well I can't tell what's going on. But the last time I thought it was hung up, it wasn't. Two hundred.
[01:31:26] Christopher David: Okay, it's going.
[01:31:30] Christopher David: Yeah, it's going, let's see.
[01:31:52] Christopher David: That is good, but I don't see any changes.
[01:31:57] Christopher David: So what is it doing?
[01:32:15] Christopher David: Repo path.
[01:32:19] Christopher David: Interesting.
[01:32:22] Christopher David: Out of curiosity,
[01:32:23] Christopher David: what happens if I did this?
[01:32:33] Christopher David: And it actually has changes.
[01:32:35] Christopher David: Cool.
[01:32:39] Christopher David: What changes did it make?
[01:32:47] Christopher David: It's trying to do the same work that we're doing.
[01:33:07] Christopher David: Whoa,
[01:33:08] Christopher David: no,
[01:33:09] Christopher David: it's a bunch of removals.
[01:33:24] Christopher David: We're making changes, people.
[01:33:31] Christopher David: We might be almost at a good stopping point here.
[01:33:36] Christopher David: Let's just see if we can improve this.
[01:33:47] Christopher David: Is this a complete?
[01:33:48] Christopher David: Yes.
[01:33:50] Christopher David: Yeah.
[01:33:52] Christopher David: Okay, so it
[01:33:55] Christopher David: shows complete now and has this and
[01:34:04] Christopher David: this.
[01:34:07] Christopher David: I see in the temp
[01:34:13] Christopher David: path,
[01:34:15] Christopher David: which it did.
[01:34:18] Christopher David: save to the database that some changes were made, but not very good ones.
[01:34:28] Christopher David: A bunch of removals.
[01:34:33] Christopher David: Uh
[01:34:45] Christopher David: Analyze
[01:34:43] Christopher David: Here at post a
[01:34:46] Christopher David: analysis markdown code block four.
[01:34:57] Christopher David: That we can add to
[01:35:07] Christopher David: Like analyze to see how close we are to finishing that.
[01:35:12] Christopher David: First issue.
[01:35:15] Christopher David: Description.
[01:35:19] Christopher David: So we have issues for the full coding loop and then the basic code change loop which is
[01:35:27] Christopher David: generating a por I don't really care about the pull request itself right now, I just wanna see some change that are not shitty.
[01:35:38] Christopher David: Or we can open a shitty P_R_ that make fun of it.
[01:35:42] Christopher David: But I don't know that I wanna clutter this repo with poor quality.
[01:36:16] Christopher David: Completed. Stable machine implementation. Created the core state, types, implemented status tracking and transitions. Added database persistence with repo passthrough.
[01:36:24] Christopher David: Basic flow. Implemented file analysis and prioritisation. Added deep seek integration for high level analysis. I don't really have any good visibility into what models being used for what part. Added open router integration for specific code changes. Implemented change generation workflow.
[01:36:40] Christopher David: Database integration.
[01:36:42] Christopher David: Added solver states table with proper schema. Implemented state persistence in updates. Added repository path tracking.
[01:36:49] Christopher David: In progress. Change application. Change is being generated but not properly applied.
[01:36:53] Christopher David: Current limitation attempts to create new files instead of modifying existing ones.
[01:37:22] Christopher David: Current changes are too generic in our context-aware.
[01:37:24] Christopher David: 'Kay.
[01:37:41] Christopher David: Make one set of changes based on those recommendations aiming to complete aiming to let us complete the
[01:37:53] Christopher David: basic code change loop issue knowing will further refine this other whe you know elsewhere.
[01:38:03] Christopher David: What's needed to get
[01:38:07] Christopher David: basic functionality at a good place.
[01:38:18] Christopher David: Based on the analysis, the most critical changes needed are around the change application logic and repository path handling. Let me make focused changes to get to the basic code change loop working.
[01:38:34] Christopher David: Next I might make a pass on UI so I can actually see good updates of what's happening in the app and have it just be less ugly.
[01:38:46] Christopher David: Maybe, maybe.
[01:38:50] Christopher David: Well, I like this flow.
[01:38:51] Christopher David: Open agents for scoping and researching and putting stuff into an issue and then having Cursor work with it.
[01:38:58] Christopher David: It's good for now.
[01:38:59] Christopher David: These basic dumb agents are about to be replaced.
[01:39:05] Christopher David: But, you know,
[01:39:05] Christopher David: thanks and stuff.
[01:39:22] Christopher David: Apply them immediately.
[01:39:28] Christopher David: Generally,
[01:39:29] Christopher David: I want you to add more logging.
[01:39:33] Christopher David: Including good summaries of like what was just done like didn't I ask in the structured Jason response for a summary of what each change was so log that prominently so I can see it
[01:39:57] Christopher David: Got some good papers
[01:39:59] Christopher David: On the X feed.
[01:40:01] Christopher David: I'm excited to create issues based on different papers that come out.
[01:40:07] Christopher David: Yes, you're right.
[01:40:35] Christopher David: Okay, that's it. Let's see what we got.
[01:40:59] Christopher David: Analyze the issue.
[01:41:06] Christopher David: Temporary directory removed. We'll need to make sure that's not fucked.
[01:41:24] Christopher David: Let's make sure this sh actually is still there. Yeah.
[01:41:30] Christopher David: But I don't see any changes.
[01:41:56] Christopher David: Okay, I'm going to pay close attention to the timestamps of the next updates because I need to have it look to find what is going on right now because
[01:42:17] Christopher David: it's not stuck I
[01:42:21] Christopher David: don't think generating changes
[01:42:36] Christopher David: Oh, here we go.
[01:42:39] Christopher David: Maybe that.
[01:42:41] Christopher David: Generated changes for file. Create solver states. Change summary. New file creation. Create new database migration for solver states.
[01:42:50] Christopher David: Creating parent directory.
[01:42:52] Christopher David: Cute! And did it actually do that? Let's make sure I'm using the right one.
[01:43:06] Christopher David: This is using the same temporary
[01:43:10] Christopher David: path.
[01:43:11] Christopher David: Does that matter?
[01:43:22] Christopher David: Okay.
[01:43:31] Christopher David: Cool.
[01:44:07] Christopher David: All changes have been applied successfully.
[01:44:11] Christopher David: Summary of changes.
[01:44:14] Christopher David: Wow.
[01:44:16] Christopher David: Okay.
[01:44:18] Christopher David: So I'm going to call this a good stopping point.
[01:44:20] Christopher David: Obviously there's more like reasoning and algorithm refinement to do,
[01:44:24] Christopher David: but we have a basic solver loop.
[01:44:41] Christopher David: And let's just do some reporting here. So, um right one more analysis comments for that GitHub issue based on what you see here.
[01:44:52] Christopher David: Then I will close the issue because I see some changes are being made.
[01:45:00] Christopher David: The PRs we are not going to submit yet because these are not yet high quality enough.
[01:45:08] Christopher David: But it's a good start. We have the basic change loop working.
[01:45:29] Christopher David: No, put that in a markdown code block. I can paste
[01:45:33] Christopher David: Two
[01:45:40] Christopher David: Do do do do do
[01:45:44] Christopher David: Final implementation status basic code change loop working
[01:45:52] Christopher David: Do do do do do copy
[01:46:03] Christopher David: Paste and then if I want a nice PR I'll go over here and I'll say read
[01:46:13] Christopher David: issue 698 and open up PR it's done.
[01:46:25] Christopher David: Ooh does it know the
[01:46:32] Christopher David: Why did you do that?
[01:46:34] Christopher David: No, did not create a branch, you fool!
[01:46:41] Christopher David: Basic coaching, no, no, no.
[01:46:47] Christopher David: Branch, it's not issues.
[01:46:59] Christopher David: No, we have a branch,
[01:47:01] Christopher David: boom.
[01:47:01] Christopher David: Read issue 698 now so you see the comments, then make a PR to main from this.
[01:47:34] Christopher David: Created pull request six nine nine.
[01:47:37] Christopher David: Feature implement basic code change loop.
[01:47:41] Christopher David: This PR implements a basic code change loop that takes us from issue analysis to code changes as outlined in six nine eight the basic loop
[01:47:50] Christopher David: We have a state machine implemented solver state file state and code change type status tracking transitions database persistence with repo path support
[01:47:58] Christopher David: change generation flow repo management core functionality
[01:48:02] Christopher David: Yeah.
[01:48:04] Christopher David: Do you want me to flash?
[01:48:05] Christopher David: Yep.
[01:48:06] Christopher David: We did all this.
[01:48:07] Christopher David: We did all this.
[01:48:09] Christopher David: More to go.
[01:48:10] Christopher David: Got to make it good.
[01:48:11] Christopher David: Got to make it pretty.
[01:48:12] Christopher David: But we have like a core loop in place. So I'll do the formatting and stuff to clean up the PR merger.
[01:48:17] Christopher David: And then we shall continue in the next video.
[01:48:21] Christopher David: See you soon.