How I Build AI Projects From Scratch (Steal My Workflow)

Video thumbnail: How I Build AI Projects From Scratch (Steal My Workflow)
Sep 22, 202626m 26s video lengthMarina Wyss - AI & Machine Learning

The Signal

Building a portfolio project that actually advances a career requires treating it as a real, evaluated product rather than a tech-heavy demo. The central tension lies in whether a project is a mere learning exercise or a professional artifact; the speaker argues this depends on whether it solves a real problem, passes rigorous evaluation, and scales beyond personal tests.

The Case

Feasibility and Architecture

  • The project, Shelf Scanner—an app that recommends books from shelf photos—began with a command-line MVP to test if cheap vision models could reliably read spines and make recommendations.1:24
  • Latency, not cost, emerged as the primary bottleneck, with shelf-reading calls taking 10–20 seconds against a 15-second total experience goal.12:54
  • Architecture decisions followed evidence: the speaker separated shelf-reading from recommendation, as different models—specifically Claude Sonnet and Gemini Flash for vision, and GPT 5.4 Mini for recommendations—excelled at distinct stages.10:53

Rigorous Workflow

  • The speaker rejects "tech-first" development, instead documenting constraints and success metrics before writing code to ensure the AI serves the problem rather than vice-versa.1:56
  • A spec-driven, human-in-the-loop workflow requires the coding assistant to draft a proposal for every feature; the human stops the process if the AI introduces an unmade decision.6:35
  • Development includes versioning prompts, running deterministic software tests alongside AI evaluation sets, and stripping GPS metadata from user uploads to mitigate privacy risks.13:51

Career Framing

  • The speaker argues that a portfolio project gains resume-worthy weight only if it evolves into a product with a real user base, transitioning it from a "learning artifact" to "professional experience."25:35
  • The project avoids trendy techniques like RAG, agents, or fine-tuning, as the speaker asserts these add unnecessary complexity and cost without solving a verified problem.14:33

The 1 Minute Signal Take

This project demonstrates that the difference between a "tutorial-level" app and professional work is the transition from building features to validating a system. Success here isn't measured by the AI models used, but by the rigor of the evaluation metrics and the documentation of trade-offs.

Pro Analysis

Why It Matters

This workflow demystifies the transition from hobbyist experimentation to professional product engineering. It provides a blueprint for developers who feel overwhelmed by the rapid evolution of AI tools and struggle to demonstrate their value to employers.

Strategic Implications

By prioritizing modularity and evaluation, developers can create 'future-proof' projects that are easy to maintain. This approach shifts the focus from 'building an app' to 'managing a system,' which is the hallmark of senior engineering.

Evidence & Hype Audit

  • Trustworthiness: High. The content is rooted in a specific, practical engineering project rather than generic theory.
  • Bias: The speaker is an advocate for specific tools (e.g., Supabase, Vercel), but the underlying architectural principles—decoupling and evaluation—are industry-standard best practices.
  • Hype Check: The content is grounded. It explicitly discourages adding RAG or agents unless the problem requires them.

Counterarguments

Critics might argue that this spec-heavy workflow is overkill for small side projects. However, the rigor is specifically intended for developers seeking to transition into professional roles, where this level of discipline is the baseline expectation.

Role-Specific Takeaways

  • Aspiring Engineers: Follow the documentation process strictly to build defensible portfolio pieces.
  • Product Managers: Use the feasibility-first MVP model to prevent scope creep.
  • Indie Hackers: Focus on the 'separate evaluation' technique to keep costs low and latency manageable.

What to Do Next

  • Audit your current project repository for a README that outlines design decisions.
  • Define a 5-item evaluation set for your model's core task.
  • Strip metadata from any user-uploaded files to avoid privacy leaks.
  • Implement a simple logging mechanism for all LLM calls.
  • Link your code commits to specific task IDs to track progress.
  • Set a 15-second end-to-end latency budget to force architectural discipline.
Time saved:23m 14s

Share this

Tags

Written by: 1 Minute Signal Editorial Team