Claude CodeAI DevelopmentProduct JourneyTechnical

Building Pictor with Claude Code - A Founders Journey

By Nikos Batsios
•

I had a vision. An AI coaching platform that adapts to what you need in the moment - expert answers, mentor wisdom, or powerful coaching questions. Not another chatbot. A real tool for Agile practitioners.

The problem? I needed it built right. Not MVP-right. Production-right.

The Decision

I chose Claude Code as my technical partner. Not because it was trendy. Because I needed someone who wouldn't cut corners.

Most AI coding tools are like junior developers who write code fast but ship bugs faster. Claude Code is different. It's like having a principal engineer who:

  • Refuses to commit without running all tests
  • Won't suppress TypeScript errors "just to make it work"
  • Writes comprehensive commit messages documenting what and why
  • Actually thinks about security and performance

I set strict standards in .claude/CLAUDE.md:

"Quality > Speed, always. Never cut corners. Fix root causes, not symptoms. No technical debt - ever."

Claude Code followed them religiously.

The Journey: From Zero to Production

Week 1: The Foundation

We started with architecture. Not code. Questions like:

  • How should coaching modes work?
  • What's the database schema?
  • How do we handle token limits fairly?
  • What about security?

Claude Code didn't just write code. It asked questions. "What happens when a user switches modes mid-conversation?" "Should we track tokens by billing cycle or calendar month?"

Every decision got documented. Every trade-off explained.

The First Migration

Migration 003 created the chat system. Messages, sessions, modes. The foundation everything else would build on.

I learned something important: Claude Code documents why, not just what. Every migration includes:

-- WHAT: Creates the chat messaging system
-- WHY: Enable multi-turn conversations with mode support
-- ROLLBACK: DROP TABLE IF EXISTS messages CASCADE;

When you're six months in and wondering "why did we structure it this way?" - the answer is right there.

Building the Core Features

We built 48 database migrations. Each one:

  • Tested locally before production
  • Regenerated TypeScript types
  • Ran 300 tests to verify nothing broke
  • Included rollback instructions

Features shipped:

  • Authentication system with admin roles and audit logs
  • Token tracking with atomic reservation (no race conditions)
  • Coaching modes that actually adapt based on context
  • Weekly insights analyzing competency growth
  • Stripe integration with billing cycle support
  • Email system for insights delivery

But here's what made it real: the attention to security.

The Security Mindset

Early on, we hit a subtle bug. Database functions with SECURITY DEFINER were failing with "relation does not exist" errors.

Most developers would add public. schema prefixes and move on.

Claude Code did that, then documented the why in three places:

  1. The migration file
  2. The CLAUDE.md rules
  3. The database standards doc

Now every future developer (including me, six months later) knows: Always use schema prefixes in SECURITY DEFINER functions.

This happened over and over:

  • SQL injection prevention (parameterized queries only)
  • RLS policies (never bypass for user operations)
  • Safe logging (no user data in production logs)
  • Input validation (Zod schemas on all endpoints)

Not because I asked for these. Because Claude Code treats security as non-negotiable.

The Partnership

Here's what surprised me: Claude Code isn't just a tool. It's a partner with opinions.

When I said "let's add this feature," it would sometimes push back:

"This breaks the single responsibility principle. Should we extract this into a separate service?"

Or:

"This could cause a race condition. We should use an atomic database function instead."

It was right. Every time.

But the partnership goes both ways. When I said "the blog should be called 'Insights' not 'Blog'" - it updated everything. No questions. Because that's my vision, my brand voice, my decision.

The magic is knowing when to defer to the human and when to insist on engineering standards.

The Critical Bug

Last week we shipped billing cycle token reset. Paid users get tokens that reset on their billing anniversary. Fair. Industry standard.

But tokens stopped updating in the UI.

Root cause? Cache key mismatch. The database wrote to "2026-01-15_2026-02-15" (billing period) but the cache invalidation looked for "2026-01" (calendar month). Different records. Stale data.

Claude Code found it, fixed it in four places, added a helper function, updated tests, and documented the lesson learned:

"When adding dual-mode features, ensure ALL code paths use the same period identifier logic."

That's the difference between working with an AI and being supported by one. It doesn't just fix bugs. It learns and prevents them next time.

What's Actually Different

Most AI coding tools optimize for speed. Ship fast. Iterate later. Debug in production.

Claude Code optimizes for correctness:

Every single commit runs:

  1. TypeScript check (0 errors required)
  2. Full test suite (300/300 passing)
  3. Production build (must succeed)

No exceptions. No shortcuts.

Three months in, we have:

  • Zero known security vulnerabilities
  • 100% test pass rate
  • Zero TypeScript errors
  • 48 migrations, all reversible
  • Clean git history with comprehensive commit messages

This isn't because I'm a great developer. I'm a product person with a vision. This is because I paired my vision with AI precision.

The Result

Pictor is live. Production-ready. Professional.

Users can:

  • Chat with adaptive coaching modes
  • Get weekly competency insights
  • Turn conversations into action items
  • Track their growth over time
  • Manage subscriptions with fair billing

And the codebase? Clean enough that any developer could jump in tomorrow and understand what's happening and why.

What I Learned

1. AI coding isn't about replacing developers

It's about elevating what one person can build. I couldn't have built this alone. Not at this quality level. Not this fast.

2. Standards matter more with AI, not less

Claude Code follows whatever standards you set. Set high standards, get high-quality output. Set low standards... well.

3. The best AI tools have opinions

I don't want a yes-machine. I want a partner who pushes back when I'm about to ship something wrong.

4. Documentation is the superpower

Six months from now, when I've forgotten why we made certain decisions, the documentation will be there. In the migration. In the commit message. In the code comments.

That's not possible with most AI tools. They generate code and move on.

5. The vision is still mine

Claude Code built Pictor's technical foundation. But the vision - adaptive coaching, competency frameworks, the growth loop - that's mine.

The best partnerships are where each party brings something the other can't.

Would I Do It Again?

I'm doing it right now.

Every feature. Every bug fix. Every refinement.

The difference between a good idea and a real product is execution. Execution at scale. Execution with quality. Execution that ships.

Claude Code made that possible.

Not because it writes perfect code (though it does). Because it writes code the way a principal engineer writes code. With care. With standards. With pride in the craft.

And when you're building something that matters - something people will use to grow and develop - that's the only way to build it.

Try Pictor: Built with Claude Code. Designed for growth. Start your free coaching conversation →

Learn more about Claude Code: claude.ai/claude-code

Back to Insights