Learning from Today's Programming Session
I was curious about how my understanding of programming concepts could evolve through collaborative problemsolving, and today's session with Claude turned out to be exactly the kind of learning experi...
Sebastian Hondl
Learning in public through daily conversations with Claude AI
Documenting my engineering journey, mistakes, and discoveries as a student exploring with AI
Latest Posts
Debugging OAuth Token Corruption: How Session Storage Can Break Your API Authentication
I've been wrestling with one of those maddening authentication bugs that makes you question everything you know about OAuth. For days, my ShapeForge application a Node.js system that integrates with ...
When Data Structures Cascade: Fixing a Multimodal AI System's Visual Analysis Pipeline
Ever had one of those debugging sessions where fixing what seems like a simple logging issue leads you down a rabbit hole of cascading failures across multiple service layers? That's exactly what happ...
Migrating 20+ AWS Services to a Unified Architecture Without Breaking Production
Technical debt has a way of accumulating quietly until one day you realize you have over 20 different service files all talking to AWS in slightly different ways. That was the situation I found myself...
When AI Models Speak Different Languages: Adapting ShapeForge for GPT-5 Vision
I stared at the CloudWatch logs in disbelief. GPT5 was receiving "object Object" instead of our carefully captured CAD images. After weeks of building ShapeForge's CAD analysis system with Claude, eve...
Building Event-Driven Magic: My Journey from SQS Curiosity to Serverless Architecture
Sometimes the best learning happens when you ask simple questions. Today's exploration with Claude started with "what is Amazon SQS Simple Queue Service and Lambda?" and evolved into a deep dive into ...
Fixing the Model Name Maze: How We Updated ShapeForge for 2025's AI Landscape
Today's 41minute session with Claude started as what I thought would be a simple task updating our model list. But as often happens when I dive into code, this turned into an unexpected journey that ...
From 176 Colors to 15: Simplifying a React Theme System Without Losing Power
I felt overwhelmed staring at the theme configuration file. One hundred and seventysix color properties sprawled across my screen—a tangled mess of buttonPrimaryHoverBorder, modalBackdropOverlay, and ...
Building CAD Automation That Actually Works: My Journey from Brittle Templates to Self-Contained Sketches
Three days into debugging our automated linkage generator, I was ready to blame everything except my own assumptions. The code looked fine, the API responses seemed normal, but sketches kept failing w...
Developing in the Open: Why My Drive for Transparency Led to Building an Automated Blog System
I've always believed in developing in the open, but after 1,200+ hours of conversations with Claude, I realized I had a massive contradiction: I was committed to transparency, yet my most valuable lea...
Building CLI Tools That Respect Your Codebase: A CAD Feature Extraction Journey
The best tools don't just solve problems—they respect existing ecosystems. I discovered this three hours into what I thought would be a simple CAD extraction script. What started as a request to pull ...
When One Character Breaks Everything: Debugging Onshape API Authentication
The 401 error stared back at me from the terminal. Valid credentials, correct environment variables, proper URL parsing—everything looked perfect. Yet Onshape's API stubbornly refused our authenticati...
Building an AI-Powered Theme System: Architecture and Implementation Journey
What started as a simple weekend project "let users describe themes in plain English" evolved into a 27hour deep dive through CSS custom properties, React context hierarchies, and agentbased AI arch...
The Invisible Pattern Bug: When CSS Opacity Math Broke Everything
Sometimes the smallest numbers cause the biggest headaches. Yesterday, I discovered that 0.035 × 0.15 = invisible, and that revelation led me down a rabbit hole of CSS rendering pipelines, SVG pattern...
Agent-Based Architecture: Discovering How AI Can Validate Its Own Creativity
I'll revise your blog post to strengthen the learning voice, add more struggle and discovery moments, and enhance the collaborative narrative with Claude. Here's the revised version: When I first aske...
The Edit Tool That Wouldn't Edit: Lessons from Large-Scale Code Refactoring
Sometimes the most frustrating bugs aren't in your code – they're in the tools you use to write it. During the ShapeForge theme system implementation, what should have been a routine refactoring turne...
Tracing Null References Through Three Layers of CAD Assembly Logic
The error message was deceptively simple: "Cannot read property 'x' of null." I initially assumed this would be a quick fix just add a null check and move on. But finding where that null originated t...
Building a CAD Analysis Pipeline That Reads Engineering Intent
I'll help revise your blog post to strengthen the learning journey voice, add more emotional elements, and better integrate the collaborative aspects with Claude. Here's the revised version: What star...
When API Versions Collide: A Four-Bar Linkage Integration Story
Sometimes the most valuable debugging lessons come wrapped in the most frustrating packages. What started as a simple task to verify my linkage sketch creation system turned into a sixteenhour deep di...
When CAD APIs Return Arrays: The Complete Debugging Story
I spent sixteen hours debugging what should have been simple geometric calculations in my ShapeForge application. The problem? Onshape's API was returning arrays where I expected numbers, dimensions w...
The API Migration That Taught Me About Backward Compatibility
Yesterday I completed a migration from Onshape's v6 to v9 API, and what I thought would be a straightforward version bump turned into an unexpected crash course in maintaining backward compatibility. ...
The Geometric Truth Hidden in 1068 Messages: Debugging Four-Bar Linkages
I'll revise the blog post directly for you. Here's the improved version that addresses the criticism while maintaining your authentic learning journey tone: After 1068 messages, 385 tool calls, and ne...
Finding the Root Cause When Everything Looks Wrong: A Synthesis System Debug Story
Sometimes the most humbling debugging session is the one where you spend hours fixing the wrong thing. Yesterday, I discovered this the hard way while working on my ShapeForge application. What starte...
The Hidden Cost of Silent Failures: A React Component Debugging Story
There's a special kind of frustration that comes from debugging a feature that fails without failing – no error messages, no stack traces, just a blank screen where your fourbar linkage animation shou...
When Every API Call Is a Fresh Start: Learning State Management in Serverless Lambda
Today I learned that serverless functions have amnesia. Not in a cute, metaphorical way, but in a "your entire workflow just disappeared between API calls" way. What started as a routine debugging ses...
State Management in Serverless: The DynamoDB Session Pattern That Saved My Workflow
During an intense debugging session with Claude, I discovered that my mental model of serverless functions was fundamentally flawed. I'd been treating Lambda functions like traditional server processe...
The Art of Progressive Debugging: How a Todo List Saved My 16-Hour Debug Session
My browser had 47 tabs open, my console was flooded with logs I'd added but forgotten why, and I was staring at the same three files I'd been circling for hours. Sixteen hours into debugging a single ...
When Middleware Breaks the Rules: A State Machine Architecture Lesson
I thought I understood separation of concerns. After years of hearing about MVC patterns, clean architecture, and the importance of boundaries between system layers, I figured I had it down. Then I sp...
Five Hours, One Bug, Three Architectural Layers: A Multi-Agent Debugging Odyssey
Some bugs are simple: a typo, a missing semicolon, a wrong variable name. Today's bug was not one of those. What started as a user report of "animations not showing" turned into a fivehour exploration...
The Architecture Lesson Hidden in a Simple UI Bug
I'll revise your blog post to address the criticism while maintaining your authentic learning journey tone. Here's the complete revised version: Sometimes the smallest bugs teach the biggest lessons. ...
When Your Extension Won't Extend: A Parameter Detection Mystery in Onshape Integration
I spent several hours today wrestling with a peculiar bug in ShapeForge's Onshape integration. Users kept reporting that the application failed to detect context parameters on initial load, forcing th...
Debugging Distributed Intent: When "Make a Linkage" Breaks Your Entire System
It started with a simple user request: "can you make a linkage?" Five hours and 1,494 messages later, we had debugged our way through multiple system layers, discovered a routing issue that sent geome...
Spring Cleaning in Production: When File Organization Reveals System Evolution
I stared at the ShapeForge project root directory with twenty untracked files scattered everywhere, feeling completely overwhelmed. Test scripts mixed with development tools. Obsolete AWS configuratio...
Five Hours, 831 Messages, and the Real Cost of CAD API Integration
Today I learned that integrating with a CAD API isn't just about writing code—it's about bridging two completely different worlds of thinking. What started as a simple cleanup task for my ShapeForge p...
The Day I Learned That CAD APIs Don't Think Like Web APIs
Today's refactoring session turned into an unexpected education in how fundamentally different CAD APIs are from the web APIs most developers are familiar with. What started as a simple cleanup of my ...
When Your Refactoring Session Becomes an API Archaeological Expedition
What do you do when cleaning up old code reveals that your entire understanding of an API was built on shaky foundations? Today's refactoring session for ShapeForge, my CAD automation project for mech...
Refactoring ShapeForge: When Cleaning Code Reveals Architectural Truths
Sometimes the simplest intentions lead to the most profound discoveries. Today's plan felt straightforward: clean up my ShapeForge project, remove deprecated methods, and improve the codebase. What un...
Building ShapeForge: The Complete Journey from API Calls to Code Generation
What started as a simple idea "let's use AI to generate CAD sketches from natural language" evolved into a 59millionmillisecond journey that fundamentally changed how I think about AIassisted develo...
From Three Sketches to One: My Journey Refactoring a Four-Bar Linkage Design Tool
Some of the best learning moments start with user complaints. I discovered this firsthand when I realized my fourbar linkage design tool was asking users to create three separate sketches just to defi...
When Mock Data Masks Reality: Building an Intelligent CloudWatch Log Analyzer
Last week, I discovered we'd been debugging against mock data for hours. Working with Claude to build an automated CloudWatch log review system for ShapeForge, I learned that sometimes the most sophis...
Debugging a Double-Wrapping Bug: When Type Information Gets Lost in Translation
I was deep in the development of ShapeForge's 4bar linkage creation system when everything stopped working. The continue button wouldn't appear, sketches were failing silently, and the workflow state ...
From Chaos to Control: My Journey Building a Project-Aware Hooks System
As a mechanical engineering student diving deeper into software development, I discovered I had created a frustrating problem for myself: I was maintaining identical Claude Code hooks automated script...