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 focuses on methodical preparation for building an application and an AI-agent command center: tracing tasks back to the manifesto and roadmap, auditing them with several language models, and consolidating the reviews into a canonical task file. Questions about timeline inclusion, dependencies, and how best to judge conflicting model reviews remain partly unresolved. Luqman also works through a task-board design that preserves context, run history, acceptance criteria, guardrails, and verification protocols while assembling task-specific agent instructions. Early prompt previews appeared too long and generic and still required refinement and testing; he likewise expected a large automated implementation to need debugging rather than assuming it would succeed. Wider discussion covers live UI previews inside the development environment, parallel work with agent teams, controlling agent scope, validating task integrity before interface polish, and building without a strong programming background or paid third-party tools. The stream also touches on Shopify submission preparation and the need to connect product building with distribution, marketing, and waitlist strategy. Luqman presents these as observations from a public learning process, arguing that logical thinking and a clear workflow can help while leaving both the build and its eventual market results uncertain.
46 moments from the stream
- 0:56:58
A pre-submission checklist for a Shopify app
The speaker explains that Shopify app review can take time and that a rejection may trigger another revision-and-review cycle. To reduce avoidable problems, he created a checklist that must be completed before submission, with UI polishing reserved for the final stage.
- 0:58:28
Coordinating parallel work with Claude Agent Teams
The speaker describes Claude Agent Teams as a way to distribute concurrent coding tasks. In his account, the agents communicate with one another in the background, helping coordinate potentially overlapping website work and reduce conflicting changes. He also frames the channel as a public record of his personal building experience.
- 1:00:15
From Building an App to Marketing It
Luqman describes a public learning approach that starts from scratch and continues beyond building into marketing and shipping, since AI tools may help create software but do not automatically solve distribution and monetization.
- 1:02:13
Preserving Agent Context and Controlling Task Scope
He asked an agent to save a brainstorming session in a Markdown file so context would survive a switch to another task, then found that the agent had also implemented the change beyond the request—an example of why context capture and explicit agent scope matter.
- 1:03:10
An AI-Agent Workflow for UI Refinement
He reviews an interface that felt too dark and describes plans to use AI models to polish it. He also explains the value of an IDE with an embedded site preview, where an element can be selected and handed directly to an agent instead of exchanging screenshots, alongside coding tools such as Codex and Gemini Code.
- 1:06:49
Command Center Review and Phased Development Plan
Luqman reviews a command-center concept that needs periodic refreshes and an agents section, and identifies overlapping timeline nodes when several fall in the same week. He outlines a proposed two-phase plan of ten weeks each, prioritizing the initial application-building phase for its learning value, while noting that the compact, dark interface is expected to be reworked.
- 1:12:07
Priorities and Dependencies in a Task Board
He discusses representing subtasks, assigning a default priority, and using their order in a Markdown file, while noting that task dependencies make planning more complex when work overlaps.
- 1:14:45
Pre-Launch Waitlist Incentives
He explains generally that offering an incentive may help grow a pre-launch waitlist and that a larger list can improve the launch start, while leaving the expected outcome uncertain.
- 1:16:41
Preparing the Workflow Before Building
He says automated estimates produced a broad delivery range, so he is first organizing the work environment, workflow, automations, agent hub, and progress tracking, while acknowledging that estimates may change and significant bugs or problems may emerge.
- 1:17:56
Resuming Agent Work with Structured Context
He returns to a Markdown brainstorm for an agent task board and requests a concise recap before continuing, then stresses that agent behavior needs clear conventions, a system, context, and a protocol.
- 1:20:16
Running Tasks Automatically from Project Context
He outlines a run action that would execute a task without a newly written manual prompt by cross-referencing the task with notes and fresh project context, potentially using a fresh system prompt per task. He frames it as part of a command center used alongside the IDE, while remaining uncertain at this stage about whether the system can actually perform the full workflow.
- 1:24:02
Reducing the Fear of Starting with a Strong Workflow
He discusses the hesitation entrepreneurs can feel before starting a strong idea and argues that AI agents, a reliable setup, and a clear command center can reduce the friction of beginning and encourage actual building.
- 1:25:32
Building a Product Publicly from Start to Finish
He explains his preference for building a complete product and broadcasting the journey from start to finish instead of focusing on short comparison clips, making the stream a primary venue for the work itself.
- 1:27:12
Preparing an Agentic Task Board UI and Mechanics
He turns the work into concrete tasks: connect the brainstorm with tasks.md, prepare the interface before adding agentic task-board mechanics, and address the weeks dropdown. He makes small foundational changes with Claude without substantially changing functionality, notes that the current interface feels darker than desired, and realizes some prompt requirements were omitted, so the preparation continues incrementally.
- 1:30:22
Concept for an Agent-Executed Task System
An early concept extends a task board beyond task details, priority, and dependencies by adding a run action and an execution system requiring context, a verification protocol, and system-level instructions. The idea remained difficult to articulate and incomplete, and implementation had not yet begun.
- 1:35:29
Reviewing a Task-Board Prototype and Identifying Open Questions
The review examines a prototype that reorganized a task card into several tabs, with a run action, human, agent, and paired execution modes, and a possible choice of agent type for a task. A visual output is used to clarify an uncertain design, followed by focused questions about execution modes, whether sibling tasks are dependencies, the purpose and numeric badge of the history tab, and the prompt-tab settings; this page does not include the answers.
- 1:42:12
Tracking Task Runs and Their Context
The discussion explores a task-board design that records run history, unsatisfactory results, notes, and context so an agent can try a different approach after repeated difficulty. It also considers showing which agent created or performed a task, without establishing that these capabilities were actually tested.
- 1:45:51
Layered Task-Prompt Assembly with Constraints and Context
An exploration of assembling a task prompt from layered base instructions, task-specific overrides, and context drawn from project documentation, milestone state, and a codebase scan. It also covers acceptance criteria, guardrails, relevant files, external references, and a read-only preview of the assembled prompt before a run; some details and questions remain unresolved in the fragmented captions.
- 1:52:37
Preparing Before Starting App Development
He explains that he is preparing before beginning the build, including a task board and agent hub intended to map the work, and invites advice on the preparation process.
- 1:54:16
What Goes Into a Prompt Preview?
He asks what the prompt preview would look like if the prompt override, acceptance criteria, constraints, context files, and reference documents were left empty.
Got a question about something in this stream?
Ask in the group