FIXED 1 BUG. CREATED 3 MORE.
Want to back the stream? The «داعم» membership on YouTube is EGP 60 a month: badges, emoji, and I answer your questions first on stream. Become a supporter
The gist
A wide-ranging working stream focused on reviewing a Shopify app before launch, combining chat and merchant-UX refinement, fault diagnosis, and conversion of review findings into a debugging and testing queue inside a custom command center. Practical work covered crashes caused by products without images, disappearing text or attachments, slow replies, alignment problems, contextual actions, and confirmation states. A recurring conclusion was that a local fix is not proof of system readiness: human review and realistic scenario testing remain necessary. Luqman also explored agent-driven debugging through backend tests and log inspection, context management through documentation, state files, and fresh sessions, plus confirmation gates and Git checkpoints to constrain autonomous changes. Audience questions led to substantial discussion of Claude, Codex, OpenCode, OpenRouter, local models, and agentic coding tools. The practical view was that model choice depends on the task, quality, cost, and familiarity with the project, while benchmark tables must be interpreted through their methods rather than a single ranking. Many multi-model and cheaper-routing ideas remained proposed experiments rather than completed findings. The stream also covered validating product ideas with landing pages, taking products to market instead of repeatedly building, and moving from a useful first release toward scaling based on real usage. Visual brainstorming and interface design, SEO and GEO, precise product descriptions, and an Arab knowledge-sharing community were additional useful threads. Open questions remained around some latency and timeout causes, classifier-context cost trade-offs, automation reliability, and several fixes and tool trials that were not conclusively validated.
155 moments from the stream
- 1:53:59
Fixing and Testing a Bug Through Incremental Interactive Diagnosis
The speaker directs the assistant to complete the fix while guarding against new bugs, then provide specific review and testing instructions. During testing, he asks for one diagnostic step at a time and reports each result back; the visible examples indicate that the classifier then returns an expected category and confidence score.
- 1:54:52
Avoiding the Chase for Every New Tool and Model
The speaker discusses how constant tool releases, model updates, and recommendation videos can become distracting. His advice is to use what works, focus on the project, and explore alternatives occasionally instead of continually switching.
- 2:00:28
Log-Access Constraints in Agent-Assisted Debugging
The speaker finds repeatedly copying and pasting results impractical. He discusses how the current Playwright-over-MCP setup does not give the assistant smooth access to logs, and imagines a faster workflow where a debugging agent can communicate with another assistant and retrieve logs when needed; the page ends before the thought is completed, and the other assistant's exact identity remains unclear.
- 2:05:57
Tracing a Timeout in an Agent Workflow
A review of a recurring issue in a multi-step agent workflow: one step appeared to pass before another bug surfaced while proceeding. The agent was asked to explain the timeout and record it in the review section.
- 2:08:50
Letting an Agent Inspect Its Own Errors and Logs
An exploratory proposal to let the agent add an error to the task store and inspect its own log, followed by a new conversation trying a full product-enrichment flow with execution-status updates or an indicator. The captions do not confirm that the idea was completed or successful.
- 2:11:25
Rechecking a Previously Crashing Flow
He revisited a flow that had previously crashed while assessing the app’s improvement inside Shopify, noting positive progress compared with two days earlier without enough technical detail to identify the error’s cause or establish a definitive fix.
- 2:14:17
Limiting the Thinking Display to Five Lines
He proposed a UI change for the thinking tool: show no more than five lines and replace older lines as new ones arrive, then record the change as a task in the review’s fixes section.
- 2:16:40
Exploring Agent-Driven Debugging Automation
He explored whether an agent could take over a manual debugging loop in the backend: prompt the tool, watch the classifier log, analyze what happens, and return results. This was only a feasibility question, with an explicit instruction not to execute anything at that point.
- 2:23:42
Designing a Test Route for Automated Chat Debugging
A lightweight test route over the chat API was proposed so the agent could send a simple prompt, read the streamed response, and monitor server logs. Session authentication was the main blocker, while manually sending the prompt and letting the agent analyze logs remained a partial option.
- 2:31:48
Testing the Production Model Under Operational Constraints
The speaker argues that user-facing behavior should be tested with the model intended for release, because a cheaper model may not represent the shipped result. Browser automation inside Shopify also remains constrained by authentication, making backend-route and log-based testing preferable where possible.
- 2:35:06
Making Fix Verification an Agent-Driven Task
The captions indicate that the test path was added and used to send a prompt and receive a reply. The speaker then requested that the workflow instructions be revised so the agent would verify fixes, inspect logs, and debug within its available scope, involving the operator only when interaction outside that scope was required; UI screenshots were not part of the described capability.
- 2:39:48
Exploring a Web Planning Mode Versus Playwright MCP
The captions describe an unidentified mode offering rich web-based plan editing and cloud execution, with the option to run the plan in a web session or send it back to the working environment. A question was raised about how it differs from Playwright MCP, but these pages contain no answer.
- 2:43:02
Advanced planning for complex coding tasks
He described a proposed workflow in which a complex task begins with a detailed plan that can be reviewed and edited before execution, and expressed interest in trying it. He also mentioned a supporting tool that can produce SVG files, effects, and animations during brainstorming.
- 2:45:32
Directing a coding agent to investigate with logs
He directed a coding agent to analyze a problem, verify whether it could access the store environment, inspect the React Router log, and identify exactly where the issue occurred. He said similar access had been configured in an earlier session and noted that Playwright could not access the shop; the captions do not show a final investigative result.
- 2:47:59
Brief anticipation for GPT-5
He expressed excitement about GPT-5 and linked it to his positive impression of GPT-4.5's strength. A brief benchmark comparison was mentioned, but the compared reference is unclear in the captions.
- 2:54:38
Why AI Model Benchmark Tables Are Hard to Read
The speaker examines a table comparing AI models by speed, an intelligence index, and several benchmarks. He notes that each benchmark scores models differently, so a single ranking is not enough to interpret performance. He acknowledges that understanding the metrics requires time and familiarity with each benchmark while still regarding the comparison as useful.
- 3:01:17
An Agent That Runs Its Own Debugging Loop
After finishing the critical issues, the speaker explains that the earlier workflow required manually relaying the problem, logs, and chat result between systems and the agent. He then configured the agent to access the backend chat interface, prompt the chat, inspect the logs and result, and continue debugging on its own. He expects this to make the work much faster, although the explanation ends just as he begins to mention a drawback.
- 3:03:39
Distinguishing Debugging Token Usage from Application API Calls
The discussion distinguishes the relatively limited token usage of debugging from potentially less-controlled API calls made by the application itself. It also warns that a fully autonomous agent may fix one fault while introducing others, so the confirmation gate and multi-step processing safeguards were reviewed before manual testing.
- 3:05:47
Using Git as a Safety Checkpoint for Agent Work
The speaker discusses reviewing an agent’s changes and using Git as a recovery checkpoint, while avoiding commits or pushes until the changes are confirmed as the version worth keeping.
- 3:07:05
Managing Context Windows with Documentation, Memory, and Parallel Sessions
The speaker discusses long chats forgetting older material and explains how strong documentation, memory, and system instructions make it practical to open fresh or parallel sessions instead of relying on one extended conversation. In his view, context consumption varies between tools, while a solid setup lets a new session begin a task with little direct conversational context.
Got a question about something in this stream?
Ask in the group