How I keep a single GraphQL schema as the source of truth across a client and a server: sharing the SDL, generating types on both ends, and using fragments to declare a shape once and compose it into complex reusable types.

My approach to shaping an Apollo server's GraphQL context around three fields: a resolved current user, a shared data layer, and a fresh set of DataLoaders.

The Vercel AI SDK makes it easy to call a model and stream a response, but the quickstart skips the parts that matter for a real application: forwarding the user's identity to your internal services, writing a system prompt that holds up under pressure, and building tools the model can't misuse. Here's how I approach all three.

When TanStack Form's defaultValues object narrows a union type to a more specific type than a given validation schema, TypeScript complains. However, there's a clean way to resolve it without sacrificing type safety.

TanStack Form's withFieldGroup HOC is commonly shown being used with nested objects. Though it's not as well documented, it's also possible to extract reusable form sections from flat, non-nested data shapes.

Standard autocomplete dropdowns work well for simple cases, but sometimes you want inline "ghost text" predictions like an IDE. Here's how I built a predictive text input using contentEditable, careful cursor management, and a healthy respect for the DOM.

Every TypeScript type you write is either earning its keep by catching drift, enforcing exhaustiveness, and surfacing mismatches between systems, or just decoration. Here are the patterns I reach for to keep types pulling their weight across a codebase.

Converting raster images to vector graphics involves multiple processing stages, each feeding into the next. Here's how I designed an artifact-based pipeline architecture that tracks provenance, enforces type safety, and makes debugging complex transformations straightforward.

There's a moment in every sufficiently complex form where a Zod schema isn't enough. The email is valid. The password meets requirements. And yet, there's still a bot check to run, an API to hit, an error to map back to the right field. Here's what that looks like in practice.

While integrating TanStack Form with schema validation libraries like Zod, I ran into a subtle type system gap that caused validation errors to silently fail. Here's how I diagnosed the issue and built a type-safe wrapper to prevent it from happening again.

How I built a secure sandbox for running untrusted player scripts using V8 isolates, a two-layer API architecture, and runtime code generation.

When building time series charts that display percentages, you often need to fetch both numerator and denominator values for each data series. But what happens when multiple series share the same denominator? Here's how I used TanStack Query's hashKey function to deduplicate overlapping queries and map the results back to the original data structure.

After years of working with react-hook-form, I made the switch to TanStack Form and built a reusable component library around it on top of my company's existing form components. Here are the patterns I landed on for binding these components to form state, creating intelligent buttons with automated loading states, and lazy-loading fields for better performance.

After years of struggling with challenges imposed by npm and yarn workspaces, pnpm demonstrates its ability to maintain monorepos effortlessly.

A feature for an internal Ruby project here at Quick Left necessitated parsing the domain from a URL. This seems like a problem for which there must already exist a solution, but it surprisingly turns out that there is no available solution for this seemingly simple task.

I recently wrote a blog post describing how to create your own RubyGem. The sample gem produced, aptly named dogeify, converts English sentences into "Doge" based upon the recently popular meme. For April Fools' Day, we thought it would be fun to implement this gem to convert our entire site into doge. Here's how we did it.

Building your first Ruby gem may seem like a daunting task, but it's actually not so bad. It's quite rewarding to not only release a gem, but to see its download count climb as others put your hard work to good use, and even still as others offer to contribute new features and bug fixes to your very own gem. And thanks to RubyGems.org and Bundler, the process of creating, releasing, and implementing gems couldn't be easier.

Implementing forms that are associated with models -- specifically ActiveRecord objects -- is pretty common when developing with Ruby on Rails. In fact, the built-in FormHelper assumes that you're working with some kind of persisted object.

But what happens when you want to create a form for something that is not persisted by an ActiveRecord model?