I built a production SaaS for a charity as a volunteer in the last 3 days of this long weekend. Here’s the methodology that made it possible and why it’s still Agile where it counts (yes we still need Agile, it does work and natural, but for software development with AI, we need a hybrid approach).
Wait, What Did I Just Say?
Three days.
7 sprints, 21 Features 70 EPICs and over 200 stories. Alone, all by myself (while still spending time with my family and friends!)
A complete multi-tenant platform, with a website, a web content management System donors portal donation Management System, Payments. Admin panels. Automated testing. Live in production.
If you’re skeptical, good. You should be.
But here’s the thing, I didn’t work 72 hours straight. I didn’t cut corners. And I didn’t sacrifice quality (or my sleep, actually hosted bbq on Sat night and spent 4 hours on landscaping too!).
in the last 2 years what I have achieved (weekends, evening, sleepless nights, so much frustration but with I WILL MAKE AI WORK attitude) is synchronising my mind with AI. And I ask everyone to achieve that , then you can truly harness the power of AI.
Let me show you.
What I Shipped in 3 Days
Before I explain how, let me prove this is real:
This is a multi-tenant charity platform. Donors browse campaigns, make donations, get tax receipts. Admins manage content, track contributions, export data. Platform operators manage multiple organizations from one codebase.
Production-ready. Tested. Deployed. 3 days.
Now—how?
The Discovery That Changed Everything
It started with frustration (with Agile, no detailed design upfront but we do as we built).
I’d been using AI coding assistants for more than year now. Claude, Cursor, Windsurf, Genspark, ChatGPT, Copilot, all of them.
Each session was productive. Each delivered working code.
But after weeks of “progress,” my codebase looked like it was built by a committee of strangers who’d never met.
Because it was.
Every new chat thread = new AI = fresh mind = zero memory of yesterday.
Monday: “Build authentication” → AI creates Pattern A
Tuesday: “Add payments” → New AI invents Pattern B
Wednesday: “Connect them” → Third AI confused → Duct tape
By Friday: Spaghetti code. “Technical debt.” Frustration.
I tried to reign them (session logs, detailed commits, fast branching, micro commiting etc), but in the end I relaieased what was wrong .
They were buildign a modern new suburb with houses, parks, shopping malls, roads, walking paths - but only with a high level vision, without a detailed map yes
iteratively!
The Counter-Intuitive Solution
Instead of diving into code, I stopped.
I (Audio conversations with ChatGPT while workign in my harden + Genspark) wrote down everything first:
Every feature (21 of them)
Every user story
Every database table
Every API endpoint
Every security consideration
I used ChatGPT for requirements (full stack very detailed ). Genspark for visual mockups. Claude for technical design, drawio to visualise the design and code structure, Playwirght for automated testing plus my own built E2E framework.
Different AI tools for different phases. But all feeding into one complete vision.
Then I handed the coding AI a full roadmap, not a vague direction.
We grouped all the features EPICs and stories into 7 iterations, based on value and dependencies.
And everything changed.
Cursor with Opus 4.5 was like Miles with his Ford
(and I was Matt Damon :D, with my fellows on whatsapp watching)
The AI stopped making contradictory decisions. It stopped “forgetting” architectural choices. It stopped building features that broke other features.
Because it could finally see the whole picture.
Why Agile (with we will work it out details later approach) Fails with AI
Here’s what’s really happening:
Agile assumes:
Teams have memory
People learn from each other
Institutional knowledge accumulates
“How we do things here” exists
AI assistants have:
Zero memory between sessions
No relationships with each other
No institutional knowledge
Every session invents its own “how”
Agile was invented We couldn’t wait 18 months to see if an idea worked. So we iterated.
But AI changes the math:
PhaseHuman TeamAI-AssistedRequirements3 months4 hoursDesign2 months4 hoursDevelopment6 months2 daysTesting2 months4 hoursTotal13+ months3 days
You don’t need to iterate when you can build the whole thing before lunch.
The Methodology: Waterfall + AI + Agile
Here’s the framework I discovered. Call it “Structured Sprint” or “Informed Waterfall”—the name doesn’t matter. The process does.
Phase 1: Complete Requirements
Tools: ChatGPT, Claude, any conversational AI
Don’t start coding. Write down:
All features (be exhaustive)
User stories for each
Acceptance criteria
Edge cases
The AI helps you think through scenarios you’d miss. But you’re building a complete specification—not a backlog you’ll “refine later.”
Phase 2: Visual Design
Tools: Genspark, Figma AI, any prototyping tool
Create clickable mockups for every screen. The coding AI needs to see what it’s building.
Phase 3: Technical Architecture
Tools: Claude Opus, Cursor IDE, Draw.io
Design everything:
Database schema
API specifications
Authentication flows
Security model
Create architecture diagrams. The coding AI will reference these constantly.
Phase 4: Implementation
Tools: Cursor IDE with Claude/Gemini
Now—and only now—start coding.
The AI has:
Complete requirements to follow
Visual mockups to match
Technical specs to implement
Architecture diagrams to reference
It’s not guessing anymore. It’s executing a plan.
Phase 5: Test & Deploy
Tools: Playwright, pytest, Railway/Vercel
Run automated tests. Deploy to production. Done.
“But Wait—That’s Not Agile!”
You’re right. Phases 1-5 are waterfall.
But here’s where Agile returns.
Three days after shipping, I had a new requirement:
“Add an AI chat assistant that users can interact with while browsing campaigns.”
Did I throw away the methodology? Start a new chaotic codebase?
No. I ran the same process again—for just this feature.
The New Feature: AI Chat Integration
The Tools That Make It Work
Primary IDE: Cursor
AI-focused IDE with:
Context-aware code generation
GitHub CLI integration
Deployment CLI integration
Model switching (use different AIs for different tasks)
AI Models (Use All of Them)
Architecture Diagrams: Draw.io
VS Code extension renders diagrams live. Keep the architecture visible while coding.
Testing: Multi-Layer
Playwright: E2E automated tests
pytest: Unit and integration tests
Cypress: Human-style browser testing
Deployment: Simple
Merge to main → auto-deploy to production. No CI/CD yaml files. No Kubernetes. Just push and ship.
The Secret Sauce: Context Preservation
The AI that builds tomorrow needs to know why we built it this way today.
Without external memory, every session reinvents the wheel.
- Session Logs
Daily markdown files capturing:
What was done
Why decisions were made
Issues and solutions
Next steps
- Detailed Commits
Not just “what changed” but “why it changed”:
feat: Add chat history with 1000-word truncation
- Chose local storage over server-side for offline support
- Truncation at 1000 words balances context vs performance
- User isolation prevents cross-user history leakage
- IDE Rules
Configuration files that enforce:
Architecture patterns
Security requirements
Code style
Testing requirements
The AI must follow these. No deviation.
- Architecture Diagrams
Visual context that stays visible during development. The AI can reference the system structure constantly.
The Results
Initial build: 3 days
New feature (AI chat): Following the same process
What would have been:
2-3 sprint planning sessions
4-6 weeks of development
2 weeks of QA
Total: 6-8 weeks
What it is:
4 hours of design updates
1-2 days of development
Automated testing built-in
Total: 2-3 days
Try This Yourself
Start Small
Pick one feature. Write complete requirements before coding.
Design Before Building
Create database schema, API specs, visual mockups—all before opening the IDE.
Use Multiple AI Models
Different models for different phases. Requirements AI ≠ coding AI.
Document Everything
Session logs. Detailed commits. Architecture diagrams.
Compare Planned vs Actual
After implementation, have the AI compare what was planned to what was built.
Multi-Agent Review
Run code through multiple AI models. They catch different issues.
Test Before You Build
Write the test plan before development. If you can’t test it, you can’t specify it.
The Future
I think we’re witnessing a fundamental shift in software development.
Not “AI writes all the code” (that’s a fantasy).
Not “AI replaces developers” (that’s fear-mongering).
But: AI changes how we organise work.
Complete requirements → full design → implementation → deploy.
The old waterfall, at AI speed.
With Agile’s responsiveness to change—one feature at a time.
What’s Next?
And if you try this methodology on your own project, tell me what happens.
Does it work for you? Does it fail spectacularly?
I want to know.
The future of software development isn’t Agile or Waterfall. It’s both—at the right granularity.
#SoftwareDevelopment #AI #TechLeadership #BuildingInPublic #Startup