Problems I've worked on

The situation

AI coding agents lose all context between sessions. Existing memory tools are simple vector stores — they work for 50 facts, then fall apart. Duplicates pile up, stale information poisons search results, everything scores the same, and after a few hundred memories the context window is filled with noise instead of signal.

What I tried

Designed a memory system with multiple retrieval signals: keyword matching and semantic similarity run in parallel, results are fused using rank-based scoring, then weighted by relevance, recency, and importance. Built a knowledge graph that auto-extracts entities from saved facts with bidirectional edges and aliases. Added reinforcement-based memory decay so frequently accessed facts stay strong while unused ones fade. Bi-temporal tracking handles contradictions — when a fact is superseded, the old version is hidden from searches but history is preserved. Published on npm with pre-built binaries for macOS and Linux.

What I learned

The hardest problem was scoring. Pure vector similarity returns plausible but wrong results. Combining keyword and semantic search with rank fusion was the breakthrough — it surfaces the fact that actually helps, not just the closest embedding. Memory decay needed careful tuning: too aggressive and useful facts disappear, too slow and noise accumulates. The reinforcement model with importance-weighted floors found the right balance.

The situation

Every RAG tutorial teaches you how to build patterns, but none tell you which one to actually use. I was building RAG pipelines at work and kept wondering: is naive retrieval good enough, or do I need reranking? Is HyDE worth the extra latency? There was no easy way to compare patterns on your own data without building each one from scratch.

What I tried

Built a CLI tool and Python library that implements 8 production-tested RAG patterns: Naive, Hybrid Search, Reranking, Parent-Child, Query Decomposition, HyDE, Self-Correcting, and Agentic. One command runs all patterns against your documents and shows a comparison table. Added an LLM-powered pattern recommender, multi-provider support (OpenAI, Anthropic, OpenRouter), and pluggable vector stores (in-memory, ChromaDB, pgvector, Qdrant). Published on PyPI with full CI/CD.

What I learned

Designing a clean abstraction layer across 8 patterns with different retrieval strategies was the hardest part. The Strategy pattern for LLM providers and Template Method for the pipeline steps made it extensible without spaghetti code. Also learned that LLMs often wrap JSON responses in markdown code fences, which silently breaks json.loads() had to add a regex stripping layer.

The situation

Inherited a legacy system where engineers spent 4+ hours manually generating network reports. The process involved exporting data from multiple sources, copying into Excel templates, and manually formatting. One wrong filter meant starting over. The team was burning 20+ hours weekly on reports that leadership needed daily.

What I tried

Built Python/Pandas automation scripts that pull data from multiple sources, apply business logic, and generate formatted reports automatically. Scheduled via Celery with PyScheduler for daily runs. Added robust error handling and Slack notifications for failures. Created a simple web UI so non-technical staff could trigger reports on-demand with custom parameters.

What I learned

The hardest part wasn't the code it was understanding the undocumented business logic buried in Excel formulas. Spent 2 weeks just mapping out what the reports actually needed to show. Also learned that XLSX files with embedded shapes and charts are a nightmare to parse programmatically had to build custom handlers for edge cases.

The situation

Site engineers needed custom data queries but couldn't write SQL. Every request went through developers 15-20 tickets per week for simple filters and exports. The bottleneck was slowing down both teams. Engineers waited days for data they needed in hours.

What I tried

Designed a visual query builder with pattern matching, comparison operators, and field selection. Users select fields from dropdowns, add conditions with AND/OR logic, and preview results before export. Backend parses the UI state into safe, parameterized SQL. Added saved queries so common reports became one-click operations.

What I learned

String parsing for the query conditions was trickier than expected handling nested parentheses, escaped quotes, and operator precedence required careful tokenization. The breakthrough was treating it like a mini programming language with proper lexer/parser stages instead of regex hacking.

The situation

Leadership had no visibility into network performance or team productivity. Data existed in multiple systems but nobody had time to consolidate it. Decisions were made on gut feel or week-old spreadsheets. Teams blamed each other when issues arose because there was no single source of truth.

What I tried

Built Grafana dashboards pulling from PostgreSQL, API endpoints, and log aggregators. Designed for different audiences: executive summary for leadership (5 key metrics), detailed breakdowns for team leads, and operational views for engineers. Added alerting for anomalies and weekly automated PDF reports sent via email.

What I learned

The technical work was 30% of the effort. The other 70% was stakeholder management understanding what metrics actually mattered, getting agreement on definitions, and iterating on visualizations until they told the right story. A dashboard nobody looks at is worthless, no matter how technically impressive.

The situation

Built the backend for an automotive marketplace handling millions of vehicle records. Raw data came from multiple sources auctions, dealers, aggregators each with different formats and quality levels. The challenge: process 30-40M raw entries daily and extract 3-4M clean, deduplicated listings.

What I tried

Designed microservices architecture with Dockerized apps connected via RabbitMQ. Each service handles one responsibility: ingestion, validation, deduplication, enrichment, indexing. Used Celery for background processing with priority queues. Elasticsearch for search with custom routing by make/model. Implemented circuit breakers after a retry storm nearly took down the cluster.

What I learned

Deduplication at scale is harder than it sounds. Same vehicle appears in multiple sources with slight variations different photos, price changes, typos in VIN. Built a fuzzy matching system using Miller columns approach that catches 94% of duplicates while keeping false positive rate under 0.1%.

The situation

The marketplace needed real-time auctions where users see bids instantly. Traditional request-response wouldn't work latency kills the auction experience. Users need to see competing bids within milliseconds, not seconds. Also needed to handle bid validation, fraud detection, and state management without race conditions.

What I tried

Built WebSocket infrastructure for bi-directional communication. Each auction room is a channel; bids broadcast to all connected clients. Backend uses async Python with connection pooling. Redis pub/sub for cross-server communication. Optimistic locking in PostgreSQL prevents double-bids. Background Celery tasks handle fraud scoring without blocking the bid flow.

What I learned

WebSocket connection management is tricky at scale. Had to implement heartbeats, automatic reconnection, and graceful degradation to polling when WebSockets fail. The state synchronization between what the client shows and server truth required careful event ordering learned a lot about eventual consistency in practice.

The situation

Needed reliable LLM integration for production applications. Single-provider dependency is risky outages happen, rate limits hit, costs spike. Also needed to validate LLM outputs against schemas because hallucinated fields and wrong types break downstream systems. 8% of raw GPT-4 responses failed validation.

What I tried

Architected a multi-provider platform using LangChain and LangGraph. Fallback chain: GPT-4 → Claude → Gemini → cached responses. Circuit breakers trip after 5 failures in 60 seconds. Pydantic validation with structured output mode reduced failures from 8% to 0.3%. Built cost tracking and automatic model switching based on task complexity.

What I learned

Each provider has different strengths. Claude has better structured output compliance (0.1% vs 0.3% schema failures). GPT-4 produces more creative content. Gemini is cost-effective for simple tasks. The key insight: don't retry immediately during outages exponential backoff with jitter prevents retry storms that make things worse.