#reflection

2 posts

Catching the Wave: Arc Raiders and the Organic Spread of Gaming Moments

Reflecting on a rare gaming moment where I'm inside the wave instead of watching it pass by, and what it means to be part of something as it spreads through your community

I bought Arc Raiders on a Tuesday because I had nothing better to do.

That sounds dismissive, but it’s true. I’d seen an ad, heard vague mentions online, and when it dropped for $40 on launch day, I figured why not. No friends playing it, no hype train I was riding, just mild curiosity and an empty evening. Within an hour, I both loved and hated it more than any game I’d played in years.

Fast forward two weeks, and suddenly everyone I know is playing it.

The Ripple Effect

It started small. A few days after I bought it, my brother mentioned he’d heard about it. Then another friend picked it up. Then a colleague at work asked if I’d tried “that new extraction shooter.” Each conversation felt like watching concentric circles expand outward from some invisible center—except I was somehow already standing in the middle.

This organic spread is what I can’t stop thinking about. Nobody orchestrated it. There was no massive marketing campaign in my social circles, no influencer telling us this was the Next Big Thing. It just… happened. Person by person, conversation by conversation, the game moved through my world like a secret being passed along.

For those unfamiliar: Arc Raiders is an extraction shooter, a genre where you drop into a map, gather resources and loot, and try to extract before you die—either to AI enemies or other players. The kicker? Proximity chat. You can hear other players when they’re near you, which transforms every encounter from a pure gunfight into something far more tense and human. You hear footsteps, then breathing, then someone whispering to their teammate about whether to engage or run.

The Emotional Roller Coaster

An hour of Arc Raiders can contain both the highest highs and the most devastating lows. You’ll nail a perfect ambush, secure incredible loot, and feel like a tactical genius—only to get third-partied by another team on your way to extraction and lose everything. You’ll make an alliance with a random player through proximity chat, work together to take down a tough enemy, then wonder the entire time if they’re about to betray you.

I’ve rarely experienced such compressed emotional intensity in gaming. Some sessions I log off buzzing with adrenaline and excitement. Others I close my laptop and stare at the wall, processing what just happened. The fact that both of these can happen within the same sixty-minute window is honestly remarkable.

The Fortnite I Missed

The last time I witnessed a gaming moment like this was Fortnite. That game swept through every social circle I had—friends, family, colleagues, everyone. But I was on the outside. I tried it, bounced off it, and watched from a distance as it became a cultural phenomenon.

This time feels different, and not just because I’m actually playing. Arc Raiders isn’t Fortnite—it’s not going to dominate the cultural conversation or get fifty million concurrent players. But within my sphere, it’s having a similar effect: creating a shared language, generating stories, giving people something to bond over.

Being inside the wave instead of watching it pass feels significant. It’s easy to be cynical about gaming culture, to dismiss these moments as trivial. But when you’re actually living it—when your brother texts you about a clutch extraction, when you’re swapping strategies with a colleague over coffee—it doesn’t feel trivial at all.

The Moment We’re In

I don’t know if Arc Raiders will still be relevant in six months. I don’t know if my friends will still be playing it, or if something else will have captured our collective attention. Gaming moments are ephemeral by nature—that’s part of what makes them special.

But right now, in this specific window of time, I’m inside something as it’s happening. I’m part of the organic spread, catching the wave instead of watching it go by. And that feels worth documenting, even if it seems a little silly.

Because in the end, these are the moments we remember. Not because the game was perfect or revolutionary, but because we were there, together, when it mattered to us.

What was your “catching the wave” moment? Not just in gaming, but in anything—a book, a band, a hobby that swept through your world organically? I’d love to hear about it.

#gaming #arc-raiders #cultural-moments #reflection
By Joel Lithgow • 6 min read Continue reading →

My AI Learning Journey - Reflections and Lessons

A comprehensive reflection on everything I've learned so far about using AI tools in web development, creative projects, and problem-solving. From major successes to common pitfalls, here's what I wish I'd known when I started.

Introduction

Over the past [TIME PERIOD], I’ve been deeply immersed in learning and working with AI tools across various projects - from web development and portfolio creation to creative problem-solving and technical challenges. This post serves as both a reflection on that journey and a resource for others embarking on similar paths.

Why document this now? Because the landscape is changing so rapidly, and the lessons I’m learning feel too valuable not to capture while they’re fresh. This is meant to be a living document that I’ll continue to update as I learn more.

Major Project Successes

1. AI-Powered Portfolio Development

Project: AI-Powered Portfolio

  • What worked: Using AI to help architect the entire site structure, from component design to content strategy
  • Key insight: AI excels at helping you think through user experience flows and technical architecture decisions
  • Live example: Portfolio Link

2. Creative Problem-Solving Projects

Project: Snake Game Easter Egg

  • What worked: Collaborative iteration between human creativity and AI implementation
  • Key insight: AI can help you implement fun, creative features that you might not have the time to fully research and build from scratch
  • Live example: Try the Snake Game

3. Infrastructure & Migration Projects

Project: Epic Astro Migration

  • What worked: Using AI to help navigate complex framework migrations and modern web development patterns
  • Key insight: AI can serve as an excellent pair programming partner for learning new technologies
  • Live example: Current Portfolio

4. Content Management & Creative Workflows

Project: Editorial Process Optimization

  • What worked: Streamlining content creation workflows and establishing better creative processes
  • Key insight: AI can help you think systematically about creative workflows, not just implement them

5. Game Development & Rapid Prototyping

Project: Symbiotic Survival - Minecraft Mutualism Mod

  • What worked: Vibe coding a complex game mod in hours using domain-specific AI workflows
  • Key insight: Claude adapts its approach based on domain—game dev gets incremental, placeholder-driven prototyping that prioritizes testing mechanics over polish
  • Full story: Building a Minecraft Mutualism Mod Dev Journal

Project: He’s Going the Distance - Minecraft Difficulty Scaling Mod

  • What worked: Building on knowledge from previous mod to create gameplay-focused mod even faster
  • Key insight: Playtesting with another person revealed the mod worked better as co-op, leading to real-time difficulty tuning—AI tools enable fast iteration on game feel
  • Full story: Making a Distance-Based Difficulty Mod Dev Journal

Technical Challenges & Solutions

The Wagtail Scheduling Confusion

The Problem: One of the most frustrating experiences I’ve had was when Claude got confused about Wagtail’s scheduling features between different versions of the CMS.

What happened:

Key Lessons:

  1. Always verify version-specific information - AI training data can lag behind current software versions
  2. Cross-reference with official documentation - Use AI as a starting point, not the final authority
  3. Document issues publicly - GitHub issues help both you and others facing similar problems

Version Control & Dependency Management

Challenge: Keeping AI-suggested dependencies up to date and compatible

  • Solution: Developed a workflow for validating AI suggestions against current package versions
  • Tool: Created custom scripts for dependency checking before implementation

Django Migration Management Issues

The Problem: Claude consistently exhibits specific patterns when working with Django migrations that can create workflow issues.

What happens:

  • Creates migrations on a per-app basis rather than considering cross-app dependencies
  • Often generates migrations without meaningful names, relying on Django’s auto-generated naming
  • Frequently leaves migrations out of git commits, requiring manual review and addition
  • Better at including migrations when explicitly asked to use a specified migration name

Real-world impact:

Key Lessons:

  1. Always specify migration names explicitly - “Create a migration named ‘add_user_preferences’” vs. generic requests
  2. Review git status before committing - Check that migrations are included in commits
  3. Consider cross-app dependencies - Ask AI to analyze migration dependencies across the entire project
  4. Establish migration naming conventions - Create clear patterns for AI to follow

Solution workflow:

  1. Always request: “Create a migration named [descriptive_name] for [specific_change]”
  2. After changes: “Show me git status and ensure all migrations are included”
  3. Before deployment: “Review migration dependencies and execution order”

GitHub Issue Creation and Label Management

The Problem: Claude frequently attempts to create new labels when creating GitHub issues, rather than using existing repository labels.

What happens:

⎿ Error: could not add label: 'content-management' not found

⏺ Let me try creating the issue with just the labels that exist in the repository:

Real-world impact:

  • Issue creation fails when AI tries to use non-existent labels
  • Workflow gets interrupted by label creation errors
  • Requires manual retry with corrected label specifications

Key Lesson: Always specify to use only existing repository labels to avoid label creation attempts in issue-focused sessions.

Solution workflow:

  1. Request: “Create a GitHub issue using only labels that already exist in the repository”
  2. Alternative: “First show me the existing labels, then create the issue with appropriate ones”
  3. Context separation: Handle label management in dedicated sessions separate from issue creation

Performance Optimization Learning Curve

Challenge: AI sometimes suggests solutions that work but aren’t optimized for performance

  • Solution: Learning to ask better questions about performance implications upfront
  • Example: Asking “What are the performance considerations of this approach?” along with implementation requests

Tools & Workflows That Changed Everything

1. Claude Code

Game-changing features:

  • Contextual understanding of entire codebases
  • Ability to work across multiple files simultaneously
  • Excellent at explaining complex technical concepts

Best practices I’ve developed:

  • Always provide full context about the project structure
  • Ask for explanations along with implementations
  • Use it for code reviews and architecture discussions

2. AI-Assisted Debugging

Workflow that works:

  1. Describe the problem and expected behavior
  2. Share relevant code snippets and error messages
  3. Ask for multiple potential solutions with explanations
  4. Test implementations incrementally

3. Content Creation & Documentation

Where AI excels:

  • Creating structured outlines (like this blog post!)
  • Generating comprehensive documentation from code
  • Brainstorming creative angles for technical content

Unexpected Learning Moments

1. AI as a Learning Accelerator

Surprise discovery: AI doesn’t just help you build things faster - it helps you understand things faster.

  • Example: Learning Astro’s island architecture through collaborative explanation and implementation
  • Insight: The best AI interactions are conversations, not just commands

2. Creative Confidence Boost

Unexpected benefit: Having AI as a brainstorming partner has made me more willing to attempt ambitious creative projects.

  • Example: The interactive portfolio elements I never would have tried before
  • Insight: Sometimes you need a collaborator who never judges your “stupid” ideas

3. Better Problem Decomposition

Skill development: Working with AI has made me better at breaking down complex problems into manageable pieces.

  • Before: Feeling overwhelmed by big technical challenges
  • After: Naturally thinking in terms of step-by-step solutions

4. Domain-Specific AI Behavior: Game Dev vs Web Dev

Surprise discovery: Claude Code fundamentally adapts its coding approach based on the domain you’re working in.

The Pattern I Noticed:

  • Web development: Tends toward production-ready code with complete implementations
  • Game development: Incremental, placeholder-heavy, TODO-driven prototyping approach
  • “Completion” means different things: Web = done and polished. Games = working prototype, next chunk unlocked.

The Concrete Example: While building a Minecraft mutualism mod, I discovered leaves were withering away even though they were attached to wood blocks. Bug, right?

Not exactly. Investigation revealed Claude had set up custom blocks using generic Minecraft block models—enough to get them rendering and testable in-game—but not properly inheriting from the specialized PillarBlock and LeavesBlock classes they needed for correct behavior.

It was intentionally halfway. The blocks worked well enough to test core game mechanics, with the expectation of refactoring to proper specs later.

The Insight: This is actually brilliant for game development. Game mechanics need to be felt and tested iteratively to know if they’re even fun before you invest in polish. You don’t need perfect pathfinding to test if “follow the bird to honey” is an engaging mechanic. You don’t need optimized algorithms to validate whether “destroy nest → no fruit” feels right as a game consequence.

Key Lessons:

  1. Embrace domain-appropriate workflows - What works for web doesn’t always work for games, and vice versa
  2. TODOs as creative scaffolding - In rapid game prototyping, TODOs aren’t tech debt—they’re markers of “good enough to test the next idea”
  3. Know when “done” means “done” - Understand the difference between “works for testing” and “production ready”
  4. Expect refactoring - Halfway implementations to enable rapid iteration are a feature, not a bug

Real-world impact: This realization changed how I approach creative prototyping. Instead of fighting the placeholder-heavy approach, I now lean into it during exploration phases—but with clear markers for what needs production-level implementation later.

Read the full story: Building a Minecraft Mutualism Mod Dev Journal

Common Pitfalls & How to Avoid Them

1. Over-reliance on AI Suggestions

Pitfall: Implementing solutions without understanding them Solution:

  • Always ask “Can you explain why this approach works?”
  • Implement incrementally and test each step
  • Keep learning fundamental concepts alongside AI assistance

2. Version & Context Confusion

Pitfall: AI providing outdated or framework-specific solutions Solution:

  • Always specify versions and context upfront
  • Verify suggestions against current documentation
  • Test in small, isolated environments first

3. Scope Creep in AI-Assisted Projects

Pitfall: AI makes everything seem possible, leading to overambitious project scope Solution:

  • Define clear project boundaries before starting
  • Use AI for feasibility checking, not just implementation
  • Regular check-ins on project scope and timeline

4. Migration and Database Change Neglect

Pitfall: AI-generated database changes often omit proper migration management Real Example: Working on Django projects where migrations were consistently generated without meaningful names and excluded from commits Solution:

  • Always explicitly request: “Create a migration named [descriptive_name]”
  • Run git status after any database changes to verify migrations are included
  • Establish and communicate clear migration naming conventions
  • Ask AI to consider cross-app migration dependencies

5. Not Documenting Learning

Pitfall: Moving too fast and not capturing valuable insights Solution:

  • Keep learning logs (like this post!)
  • Share discoveries with others
  • Create reference materials for future projects

Current Status & Next Steps

Where I Am Now

  • Comfort level: Confident using AI for most technical tasks while maintaining healthy skepticism
  • Workflow: Established reliable patterns for AI-assisted development
  • Learning focus: Deepening understanding of AI capabilities and limitations

Immediate Next Steps

  • Expand Creative Applications: Exploring AI assistance in visual design and art projects
  • Improve Prompting Techniques: Studying advanced prompt engineering for better results
  • Community Engagement: Sharing learnings and learning from others in AI development communities

Long-term Goals

  • Teaching & Mentoring: Helping others navigate AI-assisted development
  • Tool Development: Building custom tools that enhance AI workflows
  • Content Creation: Regular blog posts documenting ongoing learning

Resources & References

Live Project Examples

GitHub Issues & Discussions

Tools & Platforms Currently Using

  • Primary AI Assistant: Claude (with Claude Code for development)
  • Version Control: Git with AI-assisted commit messages and documentation
  • Documentation: AI-generated technical documentation with human review
  • Learning Resources: [TO BE ADDED - specific courses, books, communities]

Communities & Learning Networks

  • [TO BE ADDED - Discord servers, forums, meetups related to AI-assisted development]

Final Thoughts

The most important lesson I’ve learned is that AI is not a replacement for learning - it’s an accelerator for learning. The developers who will thrive in this new landscape are those who use AI to deepen their understanding, not to avoid it.

Every challenge documented here, every success celebrated here, is part of a rapidly evolving landscape. What’s true today might be different tomorrow, and that’s exactly why documenting this journey feels so important.

What’s next for this post? I plan to update this regularly as I continue learning. If you’re on a similar journey, I’d love to hear your experiences and lessons learned.

This post was created as a living document and will be updated regularly with new insights, projects, and lessons learned. Last updated: October 2025

Connect with me: [Contact information or links to social profiles]

Appendices

A. Project Timeline

[TO BE ADDED - chronological overview of major AI-assisted projects]

B. Tools & Versions Log

[TO BE ADDED - detailed breakdown of tools used, versions, and compatibility notes]

C. Prompt Templates

[TO BE ADDED - successful prompt patterns for different types of tasks]

D. Troubleshooting Guide

[TO BE ADDED - common issues and solutions for AI-assisted development]

#ai #learning #web-development #tools #reflection #lessons-learned
By Joel Lithgow • 15 min read Continue reading →