Skip to content
Nick Hawn
  • Home
  • Work
  • Writing
  • Resume
  • Contact

Writing

Notes on shipping software.

Essays, tutorials, and lessons learned. Shipping software, wrangling AI, going deep on TypeScript, and the small habits that make a team click.

  • March 2026
    What I Learned From My Claude Code Dashboard

    What my Claude Code usage actually looked like when I measured it, and the surprising patterns it surfaced about how I work with AI.

  • December 2025
    Type-Safe Python for TypeScript Developers

    A field guide for TypeScript developers who want the same confidence in Python: typing, static analysis, and the editor tooling that makes it click.

  • August 2025
    Building an AI Agent with LangGraph

    A weekend project turned tutorial: stitching together an LLM, a graph of tools, and LangGraph to get a news aggregation agent that actually works.

  • May 2025
    The Power of Context in Cursor and Other Tips to Get the Most Out of the AI Editor

    The difference between Cursor magic and Cursor frustration usually isn't the model. It's the context you feed it. A short list of habits that pay.

  • February 2025
    Empower Teams Through Thoughtful Transitions

    Handoffs are where accumulated team knowledge leaks. What I've learned about making them so clean the team barely notices you're gone.

  • October 2024
    Build Resilient API Clients: Implementing Retry & Circuit Breaker Patterns

    Your integration tests pass; prod is a different story. Two patterns that make API clients survive the real world: retry and circuit breaker.

  • July 2024
    Build an SQL Query from Variables with Prisma Raw Query (prisma.$queryRaw)

    When Prisma's fluent API runs out of runway, $queryRaw is the escape hatch. How to build dynamic, filterable, orderable SQL without losing your nerve.

  • July 2024
    Module Augmentation is a Hidden Gem in TypeScript

    A TypeScript feature most developers skip over: extending third-party modules without forking or wrapping them. Small trick, big payoff.

  • May 2024
    Let's Explore OpenAI Function Calling

    The moment an LLM stops being a chat toy and starts being a software component. A walkthrough of wiring function calling into a real app.

  • February 2024
    Beyond Software Best Practices: Why I Prefer "Leading Practices"

    "Best practices" is a finish line that doesn't exist. Why I swap the phrase for "leading practices," and why it changes how teams argue about them.

  • November 2023
    Navigating the Differences Between MongoDB and AWS DocumentDB in Practice

    The docs say DocumentDB is MongoDB-compatible. The production errors say otherwise. A list of gotchas I hit the hard way.

  • August 2023
    Get Real-Time Updates With Server-Sent Events

    Before you reach for WebSockets, consider SSE: one-way real-time updates with a fraction of the setup. When the simpler tool is the right tool.

  • March 2023
    Goodbye Google: Why I Now Use Neeva Search

    Two years off Google. What I gave up, what I got back, and what it feels like to search the web without being the product.

  • January 2023
    Level Up Your Product Demos with Arc Browser

    Arc isn't just a better daily browser. It's a secret weapon for product demos. The features I reach for before sharing my screen.

  • November 2022
    How to Test React Components with Storybook Interaction Tests

    Testing React components is a mess of trade-offs between unit, integration, and visual. Storybook interaction tests collapse some of that triage.

  • June 2022
    Updating TypeScript Declaration Files from Definitely Typed

    What to do when a library's @types package is wrong: fix it locally, then give the fix back to Definitely Typed so nobody else pays the same tax.