Project RELAY
The <72h Logic Validation Sprint
Company: The Memetic Design Lab
The Mandate: Validity > Fidelity
The Premise: Most internal tools fail because teams focus on Fidelity (Pixel-Perfect UI) before Validity (Solving the core friction). This creates Logic Debt—beautiful software that solves the wrong problem.
Role: Product Architect & Solo Builder
Timeframe: 72 Hours (Concept → Production)
Stack: Lovable (React), Supabase, OpenAI, Gemini
Status: Live v1.0
The Diagnostic:
The Environment: A multi-agent household operating under High Entropy (chaos).
The Friction: The Coordination Tax. Data entry is typically wrapped in High Voltage emotion, causing the operator to reject the input.
The Solution: A Domestic API acting as a Galvanic Isolator—stripping emotional noise from the signal before it hits the database.
I inverted the traditional design workflow. Instead of starting with Figma (Pixels), I started with the Operating Logic. I used LLMs to "simulate" the system behavior before writing code
Phase 1: The Translation Engine (Gemini)
I treated my sociological framework ("LifeOS") as the source code, using Gemini to translate abstract concepts into a technical PRD.
Input: Research on Relational Debt and Entropy.
Output: A rigid data schema defining Load Scores (1-5) and Signal Isolation protocols.
The Architecture: De-Risking the Logic
Phase 2: The Logic Layer (The System Prompt)
To prevent Logic Debt, I wrote the System Logic to enforce the protocol constraints explicitly.
By validating the business logic in the prompt (e.g., stripping adjectives, assigning load scores), we removed the need for complex backend filtering.
By operating as a Systems Architect, I removed the Coordination Tax that typically exists between Design and Engineering.
Scaffolding: Used Lovable to scaffold the UI based on an "Industrial Schematic" design prompt.
Integration: Connected directly to Supabase to enforce the schema defined in Phase 1.
The Velocity Delta: Because the Logic (Phase 2) and Physics (Phase 1) were validated before the build, the actual coding phase required minimal debugging.
The Execution: Velocity via "No-Handoff"
This tool was not built in a vacuum. It is a direct technical application of the Memetic Design Framework, specifically designed to solve the Crisis of Uncertainty in a high-entropy environment.
I used the framework to identify two specific Logic Debts in the household system:
The Actor/Architect Paradox: In high-stress moments, the user is an Actor (executing tactics) but is forced to be an Architect (making strategic decisions). This context switching creates friction.
The "Double Bind": The user is trapped between contradictory commands: "Be efficient" (Tactics) vs. "Be thoughtful" (Strategy).
The Source Code: Sociology as Syntax
The Solution: RELAY acts as a Digital Ritual that enforces a Galvanic Isolation between these two modes.
The Prompt as Holding Environment: The AI prompt creates a "pocket of order", absorbing the chaotic input (The Actor) and restructuring it into clean data (The Architect).
Sensemaking via Schema: The app automates the Sensemaking process, turning raw noise into structured meaning without user cognitive load.
This project serves as a live proof-of-concept for the Systems Architecture approach. By spending 60% of the time on Architecture/Logic and only 40% on Build, I achieved a velocity impossible in traditional workflows.
Total Build Time: <72 Hours.
Logic Bugs: 0.
Adoption: 100% (Daily Active Usage).
The Takeaway: I do not just "design screens." I engineer the logic that makes the screens buildable, scalable, and valuable. This is Operational De-Risking.