I Built Silkster in Two Weekends Using AI - Here's What Actually Changed

I gave myself two weekends to test a simple question:

With current AI tools, how much of a small SaaS can one experienced engineer realistically build?

Not a no-code experiment. I've been building software for decades. I wanted to see what happens when AI handles the mechanical implementation and I focus on architecture, constraints, and economics.

Here's what happened.

The Setup

Three tabs:

• Replit (codebase + hosting)

• Grok (early implementation planning)

• Claude (prompt refinement + structured audits)

Workflow:

1. Define feature

2. Use Grok or Claude to refine implementation approach

3. Paste structured prompt into Replit

4. Test

5. Fix

6. Repeat

Nothing autonomous. No magic agents. Just tight iteration loops.

What I Built

Silkster is a structured startup idea analysis platform:

• Curated idea database (65 ideas so far)

• Market size estimates

• Competitor summaries

• Build complexity projections

• Tiered AI-powered analysis

Stack:

• React + TypeScript

• Express + TypeScript

• PostgreSQL

• Stripe

• Redis (rate limiting)

• OpenRouter for LLM access

• Hosted on Replit

Time invested: two focused weekends.

Architecture Discipline: Separate ADD from Replit Markdown (replit.md)

Replit uses replit.md as an architectural control file. Its architect agent reads it to understand and approve structural changes.

If you mix iteration notes or speculative ideas into that file, you pollute the source of truth and risk losing information when Replit overwrites it.

So I split concerns:

• replit.md = current authoritative system state

• Separate .md = running Architecture Decision Document (ADD)

The ADD logged:

• Initial assumptions

• Model changes (Grok → Claude usage patterns)

• Cost guardrails

• Security hardening steps

• Schema and search changes

• Feature tradeoffs

The unexpected benefit: the ADD became structured context I could feed back into Claude after each major change to re-evaluate architecture, constraints, and risk.

It effectively created a rolling review loop.

This separation did three things:

1. Prevented architectural drift

2. Preserved a clean machine-readable contract for the agent

3. Enabled continuous AI-assisted re-evaluation

AI accelerates changes. Without decision logs, coherence degrades fast.

Documentation becomes structural integrity, not bureaucracy.

What AI Actually Accelerated

AI removed:

• Boilerplate writing

• CRUD scaffolding

• Auth wiring

• Basic UI generation

• API integration repetition

It dramatically compressed setup time.

What it did not remove:

• Architecture decisions

• Cost modeling

• Security design

• Data modeling tradeoffs

• Monetization logic

• Knowing when to stop adding features

The code is faster.

The thinking still matters.

Real Constraints I Hit

1. AI Costs Are Non-Trivial

After integrating AI analysis via OpenRouter, I ran test requests.

OpenRouter bill after a weekend: ~$15.

That forced immediate changes:

• Strict usage caps

• Tiered access

• Cheaper models for free tier

• Claude reserved for paid users

• Hard usage ceilings

AI features are recurring cost centers. You need guardrails.

2. Security Is Easy to Ignore (Until It Isn't)

I initially focused on features.

Then I ran a structured security review using Claude:

• Auth flow analysis

• CSRF exposure

• Token storage patterns

• Rate limiting gaps

• Input sanitization risks

It surfaced multiple weaknesses.

I then scanned it with Mozilla HTTP Observatory. It flagged missing headers and configuration issues.

Fixes included:

• Redis-based rate limiting

• CSRF protection

• Secure cookie flags

• Input validation

• Proper security headers

AI can identify risk patterns quickly.

You still need to interpret and implement correctly.

3. Database Performance Shows Up Fast

Basic LIKE queries slowed down around ~50 ideas.

Switched to PostgreSQL full-text search with GIN indexes.

Performance difference was immediate.

That wasn't an AI decision. That was experience recognizing scaling behavior early.

What Actually Changed in 2026

Historically, building this solo would require:

• Weeks of boilerplate

• Manual auth wiring

• UI iteration from scratch

• Integration debugging

• Infrastructure wrestling

Now, that layer compresses significantly.

The bottleneck moves to:

• Clear specification

• Economic discipline

• Risk management

• Decision quality

AI doesn't remove responsibility.

It removes friction.

And friction used to kill solo projects.

Mistakes

• Launched too late (MVP was ready by day 3).

• Delayed security hardening.

• Built non-core features (admin dashboards, referrals) too early.

• Lost time fighting Route 53 before switching to Cloudflare.

Nothing catastrophic, but easy traps.

The Real Takeaway

The interesting shift isn't that "AI can build apps."

It's this:

One experienced engineer can now operate with leverage that previously required a small team.

Not because AI is autonomous.

Because iteration cycles compress dramatically.

If you have architectural judgment, AI compounds it.

If you don't, AI accelerates bad decisions.

That's the divide.

Silkster is live at silkster.com (public beta).

Two weekends wasn't the impressive part.

The reduction in friction was.

This article was originally posted on Silkster.com