The video above introduces the complete workflow. Use this written companion to copy the prompts, follow each stage, and apply the same process to your own project. You can use AI to help create an entire project—from the product requirement to production deployment—but good results do not come from asking an agent to “build the app” in one message. The useful approach is a controlled workflow. You decide what should be built, the agent helps turn that intent into smaller actions, and every important assumption is clarified before code is written. This is Episode 1 of Building Projects Using AI. It introduces the seven-step development workflow I use before applying it to a complete portfolio website build in the series. The seven-step workflow The process is: Define the requirements and technology. Break the work into smaller tasks. Resolve questions, gaps, and assumptions. Implement one scoped task at a time. Test the required behavior. Review the result and refine it. Perform a final code and security review. AI accelerates the work inside these stages. It does not remove the need for clear decisions or verification. Step 1: Define the requirements and technology Start with a product and technical brief. The agent needs to understand the product before it can make sensible implementation decisions. Capture at least: the problem the project should solve the intended audience the features included in the first version important user journeys functional requirements non-functional requirements such as performance, accessibility, privacy, and responsiveness preferred language, framework, database, and deployment environment constraints such as budget, time, existing infrastructure, or integrations features that are deliberately outside the current scope A useful starting prompt is: The last instruction matters. An agent should surface missing decisions instead of silently choosing a product direction for you. Step 2: Break the project into actionable tasks Once the brief is stable, ask the agent to break it into work that can be implemented and verified independently. Good tasks are not vague labels such as “build frontend.” They describe a small outcome, its dependencies, affected areas, and how you will know it works. Ask for: an ordered implementation plan dependencies between tasks the files or application layers likely to change acceptance criteria for each task validation or test steps migration, configuration, and deployment considerations Use this prompt: The purpose is not to create a long checklist. It is to create safe units of work that can be inspected before the next change begins. Step 3: Resolve clarifications before implementation Before writing code, explicitly ask the agent what is still unclear. Clarification exposes gaps and assumptions while changing them is still inexpensive. Questions may cover: conflicting requirements undefined user states authentication and authorization boundaries error handling data ownership and retention browser or device support third-party API behavior accessibility expectations deployment and rollback requirements A direct prompt works well: Answer the important questions and add those decisions back to the brief. That gives the implementation a stable source of truth. Step 4: Implement one scoped task Now ask the coding agent to implement a specific task using the approved requirements and constraints. Keep the request narrow: Working task by task makes failures easier to diagnose. It also prevents an agent from changing the design, data model, and deployment strategy simultaneously without review. You can use the coding agent you prefer. In my workflow I use Codex, but the seven stages are not tied to one tool. Step 5: Test the required behavior Implementation is not completion. Test the feature against the acceptance criteria from the task plan. For a web application, this normally includes: the primary user journey validation and error states desktop and mobile layouts keyboard navigation and visible focus API and database behavior loading and empty states console and network errors build and production-start checks Ask the agent to show what was tested and what was not available to test. “The build passed” does not prove that the user journey works. Step 6: Review and refine the result Compare the implementation with your expectation. If the layout, behavior, wording, or technical decision is wrong, give specific feedback and repeat the implementation and testing loop. Useful feedback identifies: the exact screen, route, component, or behavior what currently happens what should happen instead what must remain unchanged Avoid restarting the entire task for one correction. A focused revision protects the parts that are already working. The loop is: Repeat it until the feature satisfies the requirement rather than merely looking plausible. Step 7: Perform code and security review Before deployment, review the completed change as a system—not only as a user interface. Look for: requirements that were missed inconsistent behavior between layers authentication or authorization gaps exposed secrets or sensitive logging unsafe input handling unexpected internal errors returned to users missing rate limits on abuse-sensitive endpoints database and migration risks inaccessible interactions performance regressions stale code and dependencies introduced by abandoned approaches Then fix the findings and rerun the relevant tests. Code review is especially important with AI-assisted development because generated code can be convincing while still containing hidden assumptions or security mistakes. A reusable project checklist Before calling an AI-built feature complete, confirm: [ ] The product and technical brief reflects the intended outcome. [ ] Scope and exclusions are explicit. [ ] Work is divided into independently testable tasks. [ ] Blocking questions and assumptions are resolved. [ ] Implementation follows the repository and technology constraints. [ ] Acceptance criteria were tested in the real interface or runtime. [ ] Feedback was applied without breaking unrelated behavior. [ ] Code, security, accessibility, and deployment risks were reviewed. [ ] The final state is clearly separated into implemented, tested, committed, pushed, and deployed. Why this workflow works The seven steps give the AI agent more useful context at the moment it needs it. Requirements guide planning. Planning exposes questions. Clarifications stabilize implementation. Tests create evidence. Review catches product mistakes. Code review catches technical and security gaps. The agent can do substantial work across the process, but you remain responsible for product decisions, approvals, and the evidence required to release the result. This workflow becomes the operating system for the rest of Building Projects Using AI, where we apply the same stages to real projects rather than discussing them only in theory.