Building AI Apps Live from Cairo đź”´
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
The stream centers on time-boxed polish for a terminal-themed website: reviewing visual hierarchy, reducing clutter, and iteratively refining a “code rain” effect—its motion, density, visibility, and content—through precise feedback, screenshots, and component references. Luqman argues that coding agents need specific direction and should understand a project before editing it, then explores an Explorer–Planner–Builder workflow with automatic context assembly, prompt previews, and verification before handoff. The value of a fully automated pipeline, exploration quality, CLI task resumption, and unexpected behavior in plan mode remain unresolved. Other discussions cover Nightbot and social-distribution automation, an unfinished YouTube API integration for live status and schedules, and pre-launch marketing through a clear landing page and waitlist while distinguishing a global product market from an Arabic knowledge audience. Audience topics include practical streaming advice, choosing web or mobile development according to the project, reading AI benchmarks cautiously, and brief questions on core AI concepts. Preferences involving Claude, Codex, Cursor, and Warp are presented as personal judgments, and the stream does not establish that every proposed improvement or test was completed.
63 moments from the stream
- 0:54:29
Making a Static Interface Feel More Alive
The interface was considered directionally acceptable but too simple and static. The work involved section screenshots, component-library research, and precisely defining a progress-bar interaction, with the observation that describing, researching, or brainstorming an idea with AI takes time and that reference sites can help communicate the intended behavior.
- 0:59:08
Choosing a Coding Assistant for UI and Reading Benchmarks Carefully
The speaker gave a personal impression that one tool was particularly good at polishing UI experience and layout, while noting that Codex could also handle the work and that preference is influenced by familiarity. He then expressed interest in understanding model benchmarks and their many metrics, cautioning that a single score does not show the whole picture.
- 1:00:29
Understanding Model Benchmarks Before Choosing a Primary Agent
The speaker discusses using benchmark results to form a broad picture of model capabilities, while noting that he still wants to understand those benchmarks better, and shares a personal preference for a Claude model as his primary agent.
- 1:04:31
Drawing Inspiration from Interface and Pricing Effects
The speaker points out visual effects he likes on a website, including one used in its pricing presentation, and considers adapting them for his own design.
- 1:06:03
Project Mapping and Task-Board Execution Tracking
The speaker asks an agent to understand the project and its task-board tab, then explains a control center that maps the project from start to finish, divides work into domains and phases, tracks progress and schedule drift, and includes a checklist for launching a Shopify app. He also expresses some uncertainty about the optimization and build phase.
- 1:09:26
A Unified Hub for Coordinating Multiple Coding Agents
The speaker outlines an agent hub that brings multiple coding tools and agents into one place, with an activity feed showing what different roles accomplished, support for exchanging notes, and shared state for recording task developments.
- 1:10:26
An Agent Task Board That Builds Prompts from Project Context
A walkthrough of a task board that organizes work by stage, priority, assignee, dependencies, notes, and prior execution attempts. It assembles a prompt preview from the task name, current stage, history, dependencies, agent type, configuration files, and other context, then can start a new execution session and report its state back to the control app. Direct execution inside the command center was mentioned as a possible but currently unnecessary extension.
- 1:17:31
Brainstorming Above-the-Fold Improvements Before Implementation
After judging the new version better than the previous one, the work shifted into planning mode to focus on the above-the-fold area before implementation. Ideas included a subtle code-rain effect, better grounding for a logo that felt as though it was floating, and gentle motion changes near the logo. The speaker also described a workflow of discussing possible directions, selecting a preferred angle, and handing off a prepared prompt to another model for polishing or experimentation.
- 1:20:29
Adding Visual Depth to a Hero Without Noise
A discussion of improving a hero with a flat dark background by adding intentional depth without restoring visual clutter, favoring a terminal-monitor direction and reconsidering the code-ring element.
- 1:22:04
Designing Precise Prompt Preview and Agent Handoffs
An explanation of why UI prompts require high specificity and how a prompt tab could preview content assembled from Markdown sections selected by agent type and domain. The workflow passes context and work from explorer to planner to builder while allowing the prompt to be reviewed and polished before execution.
- 1:29:46
Unexpected Execution Despite Plan Mode
An observed coding-assistant behavior in which actions were executed despite explicit instructions not to execute and despite plan mode being enabled. The captions do not establish the cause or a solution.
- 1:31:29
Adding a verification protocol to an agent workflow
The discussion says an agent should not hand off a task before user approval or verification, then requests an explanation of the assembled-prompt preview with pipeline mode disabled, using a simple Shopify task to show how the prompt is assembled in the backend.
- 1:33:30
Reviewing a project before running a handoff prompt
The captions show an attempt to have Codex understand the project before receiving the handoff prompt. The speaker observes that a lengthy review can consume a substantial part of the context window and plans further testing before March 29, without claiming those tests were performed or successful.
- 1:42:06
Tracing a Preview Flow Through the UI, IPC, and Application Files
Luqman reviews the “generate preview” flow step by step: the UI saves data and calls IPC, the request reaches the main process, and he searches for the relevant renderer and task-board files. When the expected landing-page changes are not visible, he checks paths and line references and considers restarting. He also says he will not add something for a task he does not understand well before reviewing its details.
- 1:54:47
An Explore–Plan–Build Agent Pipeline
The speaker considers using a pipeline for most tasks: an explorer first investigates the task and project, passes its findings to a planner, and the resulting plan then goes to a builder for execution. The motivation is having a clear desired outcome but limited technical familiarity with the project, while still needing to understand the workflow step by step before relying on it.
- 1:58:03
Reviewing Generated UI and Preparing a Session Handoff
The speaker reviews a generated interface and objects that the requested “code rain” effect was rendered as a simple grid rather than the intended effect. He asks for a detailed handoff prompt for another session explaining the concept and prior work, and questions how UI requests should be phrased to avoid this mismatch. In this context, he also expresses dissatisfaction with the model named in the source; this is his opinion at the time of the stream.
- 2:01:42
Automatic Context Assembly by Agent Type
An explanation of an assembler that does not merely pass through the user prompt, but wraps it with automatically gathered context—such as project conventions, milestone state, and code pointers—filtered for the selected agent type.
- 2:02:17
Calibrating the Visibility of UI Effects
A review of an intended visual treatment involving scan lines and limited-column code rain. The speaker found the code rain imperceptible and focused on whether the effect needed stronger visual calibration or was absent altogether.
- 2:03:29
Evaluating an Explorer–Planner–Builder Pipeline
A discussion of a workflow where an explorer investigates the codebase for task-specific findings, a planner turns those findings into an implementation approach, and a builder executes the task. It questions whether this sequence remains useful without detailed per-task configuration and asks about its benefits and possible overhead.
- 2:08:01
Pipeline Limitations Without Task Configuration
An examination of what pipeline stages receive when no prompt overrides, context files, or explicit criteria are supplied. The stated conclusion is that the concept is powerful in theory, but the explorer may operate with sparse, generic context, weakening what reaches the planner and builder and making generated-prompt quality critical.
Got a question about something in this stream?
Ask in the group