📝 This post is part of my 30 Projects in 30 Weeks challenge. I’m documenting the workflows, experiments, and lessons I pick up along the way.

If you’re building with AI tools like Claude, Cursor, or Windsurf, you don’t need a heavyweight Software Development Life Cycle (SDLC). A 4-phase minimalist agentic coding workflow can get you to faster, safer deployments without the overhead.

Ever feel like traditional SDLC slows you down when all you want to do is ship code that works? For solo developers or small projects where quick feedback and revenue matter, a lighter workflow is often the smarter choice.

For my 30 Projects in 30 Weeks Challenge, I’ve been refining what I call a “minimalist agentic coding workflow”, or a “minimalist vibe coding workflow” and it’s completely changed how I approach solo development. Instead of six SDLC phases, I’ve stripped it down to four essential steps that actually match how modern AI-assisted development works.

4️⃣ 4-Phase AI SDLC Workflow for Fast Development

Here’s the framework that’s been working for me:

1. Spec & Guardrails

• Human sets intent → clear task, requirements, and security constraints.
• AI agent generates design/code plan.
• Guardrail: prompt always includes “generate securely, check for vulnerabilities.”

2. Code & Self-Review

• AI (or multiple agents) generates the code.
• Second pass: AI audits its own output, lists risks, proposes fixes.
• Human reviews or accepts with suggested changes.

3. Test & Stage

• Automated tests and security scans run on every PR/merge.
• Deploy to staging environment for quick smoke tests.
• Guardrail: CI/CD blocks merge if tests or scans fail.

4. Deploy & Monitor

• Merge to main → auto-deploy to production.
• Logs, alerts, and rollback ready.
• Guardrail: audit trail links AI-generated code to commits.

I talked a bit more about this here.

💼 The Structure for a Minimalist AI-Aware Workflow

Agentic: AI does codegen + review, human supervises.
Minimalist: 4 phases instead of 6–8.
Secure: built-in checks (prompting, scans, staging) before code ever hits users.
Flow-friendly: you can vibe-code with AI, but there’s always a safety net.

For security, I keep things lightweight but deliberate: one AI agent handles DevOps setup, another runs penetration-style tests, a third does a minimalist security check on each major change and at the end of phases or tasks. Combined with CI/CD blocking unsafe merges, this keeps the workflow lean without ignoring security.

That’s the agentic SDLC in its lightest form: Spec → Code → Test → Deploy. The twist is that AI agents handle both creation and review, while automated security checks and environment separation protect you.

📋 Where PRDs Fit in an AI Coding Workflow

A lot of new developers and vibe coders getting into agentic coding hear about PRDs (Product Requirements Documents). Here’s where they actually fit:

Think of a PRD as the translation layer between an idea and engineering work.

• Idea → PRD (what should exist, why, and for whom)
• PRD → specs / tickets (how to build it)
• Specs → code (actual development)

The PRD is not about how to build — it’s about what should exist and why. Once it’s reviewed and accepted, you (or your AI agents) turn it into detailed technical specs, designs, and tasks.

🔁 The Clean Workflow Loop

Here’s how it fits together:

1. Capture the idea – Jot down problem, goal, or feature concept. Keep it rough.
2. Draft the PRD – Describe the problem, success criteria, user stories, constraints, dependencies, and scope. (This is the “what and why.”)
3. Review the PRD – Is this the right thing to build? Is the scope right?
4. Specs & design – Turn PRD into technical design docs, architecture, and acceptance criteria. (This is the “how.”)
5. Break into tickets/tasks – Small, actionable chunks for dev (or AI agents).
6. Build → test → release – Development proceeds against those specs using the 4-phase agentic workflow above.

🤔 Do You Need a PRD for Every Feature?

Not always. Use the 80/20 rule:

• Major features (new modules, dashboards, payment systems) → full PRD.
• Small features / UI tweaks (change a button color, add one field) → usually just a ticket/spec, no full PRD.

The PRD is a communication tool. If you need alignment (with yourself, collaborators, or AI agents), make one. If it’s obvious and small, skip it.

📄 Modern, Minimal Structure

Keep it simple with this skeleton:

• Title: Clear feature or product name.
• Overview / Problem: What’s missing or broken?
• Goals & Success Metrics: What does success look like?
• User Stories: “As a [user], I want to [do X], so that [benefit].”
• Scope (Must / Should / Could / Won’t): MoSCoW list.
• Constraints & Risks: Tech, design, legal, security.
• Dependencies: What needs to exist first?
• Out of Scope: Prevents scope creep.

⚙️ How This Looks in Practice (Spec-Driven Solo Development)

Here’s my actual process combining spec-driven development with the agentic workflow:

• Idea → capture the raw problem or opportunity
• Feature → define specific functionality needed
• PRD → write 1–2 page requirements document
• Plan → generate technical specs (API endpoints, DB schema, UI flow) from PRD
• Phases → execute using the 4-phase agentic workflow
• Tasks → break plan into specific work items for AI agents (Claude Code, Cursor, Windsurf)

The key is that each step informs the next. My PRD becomes the source of truth for what’s being built, the plan becomes the technical roadmap for how it’s built, and the 4-phase workflow ensures it’s built safely and efficiently.

This spec-driven approach is what makes agentic development reliable. Without clear specifications, AI agents tend to make assumptions or miss important requirements. With them, the AI becomes incredibly effective at executing the plan.

🤖 Why This Agentic Coding Workflow Works

This isn’t about reinventing the SDLC. It’s about running a leaner, AI-aware workflow that ships faster without cutting corners.

Four phases instead of six. Guardrails built in, not bolted on. PRDs when they matter, not when they don’t.

The goal is simple: Spec → Code → Test → Deploy — with AI doing the heavy lifting and humans staying in control of the decisions that count.

What’s your take — have you tried an agentic development workflow, and how did it work for you?

p.s. I’m still pretty sick so please excuse any mistakes or hiccups in this post.