ZDNET’s David Gewirtz shares seven disciplined AI coding practices plus code review, turning vibe coding into reliable, auditable, user-centered production software.
IDEAS:
Treat AI as a peer developer, requiring structure, constraints, and accountability like any teammate.
Prefer sequential, visible agent work because parallelism becomes unmanageable when actions are hidden.
Opaque background agents can crash, hang, and leave code changes half-finished and indeterminant.
Embed strict “one file at a time” rules to maximize recoverability when AI work derails.
Build migration tracking into the repo so multi-platform parity becomes a deliberate operational process.
Log platform-impacting changes immediately to prevent feature drift across iOS, iPad, Mac, Watch versions.
Convert every cross-platform change into a technical debt ticket until every target platform catches up.
Maintain persistent project memory files so AI sessions regain state and avoid repeating investigations.
Organize memory semantically by topic, not chronologically, improving retrieval and reducing duplicated notes.
Curate memory aggressively by deleting outdated or wrong items, preventing institutionalized misinformation from spreading.
Store key learnings like API signatures, algorithms, measurements, and fixes as durable project knowledge.
Keep a chronological prompt log to replay collaboration and diagnose failures caused by unclear instructions.
Treat prompt logs like version control for human-AI interaction, enabling auditing and reconstruction later.
Use explicit user profiles as design constraints, guiding AI choices toward real users’ comfort and needs.
When AI drifts, ask it to restate user profile, forcing re-alignment and better design decisions.
Encode design systems directly into system prompts, turning style consistency into an automated default.
Specify design tokens: font sizes, RGB colors, components, and reference implementations for reliable UI consistency.
Avoid relying on AI’s implicit recall of previous UI; provide explicit, reusable design language data.
Convert debugging pain into permanent rules, preventing the same class of AI mistakes recurring.
Embed guardrails like “never stack more than 4 sheets” to avoid silent failures on macOS.
Capture platform-specific gotchas as non-negotiable instructions, especially where Apple APIs behave unexpectedly.
End each session by recording learnings so fixes become part of project DNA, not fleeting memory.
Use AI to do periodic code reviews, simulating fresh eyes by scanning the whole project quickly.
Start new sessions by asking AI to flag issues before reading instructions, surfacing overlooked problems.
Vibe coding becomes “engineering discipline” when prompts, memory, rules, and artifacts form a workflow system.
Agentic AI acts as a force multiplier for solo developers, enabling shipping multiple serious products quickly.
Speed isn’t the goal; predictability, traceability, and quality are the differentiators for elite AI builders.
Instruction files like CLAUDE.MD and AGENTS.MD can operationalize best practices across every session consistently.
Collaboration improves when you treat AI like Slack-based teammate, not magical oracle producing infallible code.
Stereotypical user personas can work well with AI training data, producing practical, targeted design outcomes.
INSIGHTS
Eliteness with AI comes from governance: visibility, auditability, and repeatable constraints over raw speed.
Turning fixes into rules transforms debugging from recurring cost into compounding capital across future iterations.
Persistent semantic memory shifts AI from stateless helper into an evolving organization that learns responsibly.
Prompt logs create collaboration observability; without replay, you cannot debug the human-AI system.
Multi-platform work demands first-class migration artifacts, or parity collapses under incremental, local optimizations.
Design tokens in system prompts make consistency automatic, reducing subjective interpretation and rework dramatically.
User profiles are functional requirements; encoding them prevents clever implementations that betray real-world usability.
Sequential workflows outperform parallel agents when tooling hides actions, because recoverability beats throughput always.
Treating AI like a teammate clarifies responsibility boundaries, improving both prompts and engineering outcomes.
Disciplined vibe coding is essentially software management: rules, documentation, review, and institutional learning loops.
QUOTES:
“Treat the AI like another developer, not a magic box.” — David Gewirtz
“Encode design systems and user profiles in system prompts.” — David Gewirtz
“Every fixed bug becomes a permanent lesson learned in the project’s DNA.” — David Gewirtz
“As a sole coder, agentic AI has been a force multiplier of almost breathtaking capability.” — David Gewirtz
“This is vibe coding.” — David Gewirtz
“But it’s vibe coding with engineering discipline, and an underlying framework designed for robustness and product quality.” — David Gewirtz
“Do NOT use background agents or background tasks.” — David Gewirtz
“Do NOT split into multiple agents.” — David Gewirtz
“Process files ONE AT A TIME, sequentially.” — David Gewirtz
“Update the user regularly on each step.” — David Gewirtz
“I chose slower but visible over faster but opaque.” — David Gewirtz
“I don’t trust myself (or the AI) to remember changes across sessions.” — David Gewirtz
“Every change generates a technical debt ticket for every platform it hasn’t reached yet.” — David Gewirtz
“Update or remove memories that turn out to be wrong or outdated.” — David Gewirtz
“Do not write duplicate memories.” — David Gewirtz
“It’s version control for my collaboration with the AI.” — David Gewirtz
“If we can’t replay the conversation, we can’t debug the collaboration.” — David Gewirtz
“Telling the AI who uses the software helps it understand how to build the software.” — David Gewirtz
“Design consistency shouldn’t depend on the AI’s memory of what it built last time” — David Gewirtz
“Every AI mistake should only happen once, because avoiding it becomes a guardrail rule.” — David Gewirtz
“Powerful. Easy to do. Enormously effective. What’s not to love?” — David Gewirtz
HABITS
Run only one AI agent at a time, prioritizing visibility, manageability, and predictable recovery paths.
Add best practices into CLAUDE.MD and AGENTS.MD so workflows persist across future sessions.
Force sequential file processing, requiring regular status updates so you always know progress state.