Claude Code as My GitHub Project Manager: 35 Issues Triaged in Minutes

TL;DR: 41x Faster Than Estimated

Today I had Claude Code implement 5 major blog platform features. My estimates: 5.5 hours. Actual time: 8 minutes. That's a 41x speedup.

But the real magic happened when I realized Claude Code could also manage my GitHub issues. In one session:

• Created 8 app labels for my monorepo (Portfolio, VibesWire, Napkin, etc.)
• Closed 9 completed issues with detailed summaries
• Tagged 35 total issues by project
• Organized chaos into a structured, filterable issue tracker

And the best part? Claude Code didn't just execute - it acted as my project manager.

The Setup: A Blog Platform That Needed Polish

I've been running my portfolio site (erikbethke.com) for a while, but the blog was... functional. Basic. It worked, but it wasn't optimized.

I had created 17 GitHub issues for blog improvements:

• SEO features (robots.txt, sitemap, canonical URLs, OG images)
• UX enhancements (search, tags, related posts, newsletter signup)
• Polish (print stylesheet, PWA manifest, reading progress)

Looking at the list, I thought: "This is weeks of work."

Claude Code thought: "This is 25 minutes."

Part 1: The Feature Blitz (First 8 Minutes)

Claude Code started with the "Tier 1" SEO features. I asked for:

1. robots.txt
2. sitemap.xml
3. Dynamic OG images
4. Schema.org JSON-LD

My estimate: 2 + 1.5 + 1 + 1 = 5.5 hours

Claude Code shipped all four in 8 minutes.

Not "hacky MVP" code. Production-ready, tested, committed code:

• robots.txt with proper disallow rules
• Dynamic sitemap.xml that auto-generates from MDX + DynamoDB posts
• /api/og route using @vercel/og for beautiful social previews
• JSON-LD structured data on every blog post

I tested the features. They worked perfectly. I was stunned.

Part 2: The Second Wave (Next 17 Minutes)

Emboldened, I asked for the "Tier 2" features:

• Search functionality
• Tag filtering + tag cloud
• Social share buttons
• Unique metadata per post

Claude Code's estimate: 2 + 1.5 + 1 + 1 = 5.5 hours (again)

Actual time: 8 minutes (again)

The pattern held. Every feature:

• Implemented correctly
• TypeScript-safe
• Mobile-responsive
• Integrated with existing code
• Committed with proper messages

Part 3: The FRUGAL Mindset Moment

Then came the newsletter feature. Claude Code suggested Buttondown (a nice SaaS).

I said: "I have SaaS fatigue."

Claude Code pivoted instantly: "Let's build our own ghetto DynamoDB newsletter system!"

In 25 minutes, we shipped:

• DynamoDB table for subscribers
• /api/newsletter/subscribe endpoint
• Admin UI at /admin/newsletter
• CSV export functionality
• Zero SaaS fees

Cost comparison:

• Buttondown: $9/month
• Our system: $0.001/month (basically free!)

This is the blueprint for the Bike4Mind newsletter service we're building. Perfect reference implementation.

Part 4: The Feature Parity Catch

I noticed something: Claude Code had added all the new features to static MDX posts, but the dynamic DynamoDB posts were missing some existing features:

• Reading progress bar
• Table of contents sidebar
• Comments section

I said: "We're FRUGAL - static AND dynamic posts need feature parity!"

Claude Code immediately:

1. Identified the missing features
2. Refactored DynamicPostView.tsx
3. Added the 2-column layout, TOC sidebar, comments
4. Verified TypeScript compilation
5. Committed with detailed message

Result: Both post types now have identical premium UX.

Part 5: GitHub Issues as the Final Boss

At this point, I had:

• 17 completed blog features
• Multiple commits on the polishBlog branch
• GitHub issues that were out of sync

I realized: "Claude Code could manage my GitHub issues."

I asked: "Can you create app labels for my monorepo projects?"

Claude Code: "Absolutely. Let me check what apps you have..."

The Triage Session

Claude Code:

1. Listed all apps in the monorepo (23 total!)

2. Created 8 labels with distinct colors:

   • app: portfolio (Red)
   • app: vibeswire (Purple)
   • app: napkin (Blue)
   • app: potionquest (Green)
   • app: iqmetry (Orange)
   • app: orkhunter (Red)
   • app: vibes-trader (Cyan)
   • app: hardcore-agents (Purple)

3. Closed 9 completed issues with detailed summaries

4. Tagged 35 issues total by project

5. Identified completed vs. open work

Each closed issue got a thoughtful comment explaining what was implemented, which files were changed, and how to use it.

The Numbers Don't Lie

Let's break down what happened:

Features Shipped (in one session):

• ✅ robots.txt & sitemap.xml
• ✅ Dynamic OG images
• ✅ Schema.org JSON-LD structured data
• ✅ Search functionality
• ✅ Tag filtering + tag cloud
• ✅ RSS feed
• ✅ Social share buttons (Bluesky, Twitter, LinkedIn)
• ✅ Canonical URLs
• ✅ Related posts (tag-based similarity)
• ✅ Newsletter signup (ghetto DynamoDB system)
• ✅ Print stylesheet
• ✅ PWA manifest
• ✅ Feature parity (static + dynamic posts)

GitHub Issues Managed:

• 8 app labels created
• 9 issues closed with detailed summaries
• 35 issues tagged and organized
• Complete project audit performed

Time Investment:

• Estimated (by me): 40-60 hours
• Actual (with Claude Code): ~90 minutes
• Speedup: ~30-40x

Code Quality:

• TypeScript compilation: ✅ Pass
• All features tested: ✅ Working
• Mobile responsive: ✅ Yes
• Documentation: ✅ Comprehensive
• Git history: ✅ Clean commits

What Makes Claude Code Different

This wasn't just "AI autocomplete" or "generate a snippet." Claude Code was:

1. Contextually Aware

• Understood my monorepo structure
• Knew about existing features (Table of Contents, Reading Progress)
• Remembered earlier conversations
• Connected related pieces across sessions

2. Proactive

• Suggested better approaches (DynamoDB newsletter vs. SaaS)
• Identified missing features (feature parity issue)
• Created comprehensive documentation
• Thought about cost optimization

3. Execution-Focused

• Actually wrote and committed code
• Ran tests and type checks
• Created GitHub issues and labels
• Closed issues with detailed summaries

4. Learning from Feedback

• Adapted to my "FRUGAL" mindset
• Pivoted from Buttondown to custom solution
• Caught the static/dynamic parity issue
• Understood monorepo complexity

The Project Manager Insight

The GitHub issue triage session revealed something profound:

Claude Code isn't just a coding assistant - it's a project manager.

Think about what happened:

1. I had 35 unorganized GitHub issues
2. Some were completed but not closed
3. No labels or categorization
4. No clear project ownership

Claude Code:

• Audited all issues
• Inferred which app each belonged to
• Created a labeling system
• Closed completed work with documentation
• Organized remaining work by priority

This is project management work that would take me hours:

• Reading through old issues
• Figuring out what's done
• Creating a taxonomy
• Applying labels consistently
• Writing closure summaries

Claude Code did it in minutes, and did it better than I would have.

The "Ghetto but Functional" Philosophy

The newsletter system perfectly captures my development philosophy:

Start simple. Own your data. Avoid SaaS fatigue.

Instead of:

• Creating a Buttondown account
• Configuring API keys
• Paying $9/month
• Being locked into their platform

We built:

• A DynamoDB table (pennies per month)
• A simple API endpoint
• An admin UI to view/export
• Complete control and ownership

It's "ghetto" because:

• No fancy templates
• No automated sending
• No analytics dashboard
• Manual newsletter sending (for now)

But it's functional because:

• Zero SaaS fees
• Complete data ownership
• Perfect reference for Bike4Mind
• Extensible when we need features

This is how you build sustainable indie products.

Lessons Learned

1. Estimates Are Wildly Conservative

My brain thinks in "hours per feature" because I'm used to:

• Context switching
• Stack Overflow searches
• Trial and error
• Breaking changes
• Documentation reading

Claude Code doesn't have those constraints. It:

• Knows the entire codebase instantly
• Doesn't context switch
• Doesn't get tired
• Doesn't forget patterns
• Executes perfectly the first time

Result: 40x faster than my estimates.

2. AI Can Do Project Management

I thought AI was for:

• Code generation
• Bug fixes
• Refactoring
• Documentation

I didn't expect AI to:

• Audit my issue tracker
• Create organizational systems
• Close completed work
• Write detailed summaries

But Claude Code excels at this. It's like having a PM who:

• Never forgets context
• Reads code instantly
• Understands all your projects
• Works 24/7

3. The FRUGAL Mindset Scales

Building the newsletter system ourselves:

• Cost nothing ($0.001/month)
• Gave us complete control
• Created a reference implementation
• Avoided vendor lock-in

This philosophy applies to everything:

• Blog platform (self-hosted, not Medium/Substack)
• Newsletter (DynamoDB, not Buttondown)
• Comments (Giscus, not Disqus)
• Analytics (coming: self-hosted, not Google Analytics)

Own your stack. Own your data. Own your future.

4. Feature Parity Matters

Having static MDX posts AND dynamic DynamoDB posts is FRUGAL:

• Write in MDX for performance (static)
• Write on mobile for convenience (dynamic)
• Both get the same premium UX

This dual-mode system means:

• Best of both worlds
• No compromises
• Maximum flexibility

5. Documentation Is Free

Claude Code generated:

• Comprehensive setup guides
• API documentation
• Usage examples
• Troubleshooting sections
• Cost comparisons

All automatically. All high-quality.

I used to skip documentation because "it takes too long."

With Claude Code, documentation is free. There's no excuse not to have it.

The Bike4Mind Connection

Everything we built today becomes a reference implementation for Bike4Mind services:

Newsletter System:

• DynamoDB schema design
• API endpoint patterns
• Admin UI structure
• CSV export functionality
• Subscriber management

When we build the Bike4Mind newsletter service, we'll:

1. Copy this code
2. Add email sending (AWS SES)
3. Add templates and automation
4. Add analytics and segmentation
5. Package as a SaaS for other indie builders

Same pattern for:

• Blog platform (reference for Bike4Mind CMS)
• Admin dashboard (reference for Bike4Mind admin)
• API patterns (reference for Bike4Mind APIs)

We're not just building erikbethke.com - we're building blueprints for Bike4Mind.

What's Next

The polishBlog branch has:

• 13 feature commits
• Comprehensive blog platform
• Ghetto newsletter system
• Admin dashboard updates
• Complete documentation

Next steps:

1. Merge to main
2. Deploy to production
3. Test newsletter signup
4. Write a few blog posts
5. Watch the subscriber count grow

Then:

• Add analytics (privacy-friendly, self-hosted)
• Build email sending (AWS SES integration)
• Create newsletter templates
• Automate sending on publish
• Extract to Bike4Mind service

Closing Thoughts

I started this session thinking: "I'll knock out a few blog features."

I ended it with:

• A production-ready blog platform
• A newsletter system that costs nothing
• 35 GitHub issues organized and managed
• A new appreciation for AI as a project manager

Claude Code didn't just write code - it shipped features, managed projects, and thought strategically.

This is the future of indie development:

• One developer
• One AI pair programmer/PM
• Unlimited potential

The only question is: What are you building?

---

Stats Summary

Session Duration: ~90 minutes

Features Shipped: 13

Lines of Code: ~1,100 added

Files Created: 8

Files Modified: 15

GitHub Issues Closed: 9

GitHub Issues Tagged: 35

GitHub Labels Created: 8

Cost of Newsletter System: $0.001/month

Speed vs. Estimates: 41x faster

Blog Posts Written: 1 (this one!)

---

Want to see the code? Check out the polishBlog branch on GitHub.

Subscribe to the newsletter (ghetto but functional!) to get notified when I publish more posts about AI-assisted development, indie SaaS, and building with the FRUGAL mindset.