Email verification belongs at the API boundary
Email verification should protect the API capability that needs it, while leaving sign-in, recovery, and account management usable.
Paulund
Developer notebook — articles on AI, and software engineering.
Latest posts
Infrastructure questions belong before the first line of code
I added infrastructure discovery to my project boilerplate because generic scaffolding hides the services and failure modes that shape a real application.
SEO feedback should become bounded engineering work
A Search Console workflow can turn delayed SEO signals into bounded GitHub issues, giving agents useful work without granting them unrestricted control.
A status page should explain incidents, not just show green
A useful status page makes operational reliability visible before the first incident by showing evidence, history, notifications, and honest limits.
Agent workflows should outlive their models
I migrated scheduled agent workflows from OpenCode to Codex without rewriting their rules, and it changed how I design durable automation.
Building PostConductor: Why I Pivoted to MCP-First
Why I rebuilt PostConductor as an MCP-first tool inside the agent interface, and how the shift changed the way I design software products.
Stop Blaming the Model
Google just published a 51-page paper on the new SDLC. The single most important idea: your agent is not the model. It is the harness around it.
Harness Engineering
Cole Medin explains why a coding agent's harness matters more than its model. I compare his framing with the agent workflow I use each day.
A Modern Quality Pipeline and Testing Strategy for Frontend Projects
A practical guide to a 15-layer frontend quality pipeline, from type safety to observability, with a phased order for adopting each check.
Agents Are Cron Jobs and Markdown Files
Ryan Carson runs his startup solo with AI agents. His core thesis strips agentic automation down to schedulers and plain-text instructions.
Measure Your Agent Skills or Delete Them
Nick Nisi discovered one of his skills dropped accuracy from 97% to 77%. The lesson: skills actively hurt without measurement. Evaluate or delete.
What to Do If You're Not Detail Oriented
Wes Kao four-question self-check for shipping quality work and why you only need to be good enough at details, not in the ninety-fifth percentile for detail.
How to Stay Resilient in a Difficult Engineering Job
Seven strategies for staying intact when your engineering job drains you, adapted for developers dealing with on-call pressure, toxic environments, and burnout.
Agentic Engineering Patterns
Willison agentic engineering guide codifies patterns I use daily in my agent orchestration system. What maps, what does not, and three things I am adopting.
AI Ate the Translation Layer
Ajey Gore's thesis on AI-native organizations — why the translation layer between business and engineering is collapsing and what the new org chart looks like.
Why Smaller Teams Will Win With AI
AI narrows the advantage of large teams. Small teams move faster, have fewer handoffs and redesign without process layers. AI amplifies that speed advantage.
AI Code Review: Pre-Existing Bugs as a Side Quest
Running multiple AI models in parallel for PR review finds bugs you never knew you had. The catch? It makes you slower, not faster. And that is the point.
Software Factory: Build Factories, Not Features
How senior engineers build software factories: agentic pipelines that autonomously plan, build, validate, and ship features, compounding output over time.
Small npm Packages Are Mostly Dead
Why AI-generated code replaces the need for small npm packages, and where the line is between a dependency you still need and one an LLM can write on the spot.
The Four Levels of Working with AI
Matt Maher's four-level framework reveals most developers are stuck at level 2. Here is what level 3 looks like in practice and why it matters to move up.
What Happens to Developers Who Don't Adapt to AI
Which developer skills depreciate and appreciate in 2026, why half-adopting AI is riskier than refusing it, and advice for engineers who feel left behind.
Software Ecology and the 10x Moment
A framework for understanding developer ecosystems as socio-technical systems, and what breaks first when AI-driven velocity pushes every node to 10x capacity.
How AI Agents Made Me CLI-First
How AI agents pulled me into the terminal and changed how I build software, from nested loops and AFK workflows to risk-gated PRs and scheduled orchestration.
How I Build Software With Agent Loops
The AI-assisted development workflow I use every day, from human-in-the-loop planning to AFK implementation, risk-gated PRs, and continuous learning loops.
paulund/goldcli v1.1.0 - Caching layer keeps you under the API free tier
goldcli v1.1.0 adds local caching for gold price API responses, cutting redundant requests and keeping you safely inside the 100-request-per-month free tier.
Higher-Order Components and Why Hooks Replaced Them
What higher-order components are, how they worked in class-based React, and why hooks are a better solution for the same cross-cutting concern problems.
Pure Components and Why Purity Matters in React
Learn why React treats your components like pure functions and how keeping renders side-effect free makes your app predictable, testable, and less buggy.
React Fragments and When You Actually Need Them
Why React components must return a single root element, how Fragments solve this without polluting the DOM, and the three different ways to write them.
Refs and when useRef beats useState
I used to reach for useState for everything. Here is why useRef is often the better tool for values that do not need to trigger a component re-render.
Default Props and Optional Props in React
How to type optional props in TypeScript and set sensible default values without reaching for the deprecated defaultProps API in modern React applications.
Handling Form Submission in React
How to handle form submission in React including async submit handlers, loading states, error display, and resetting the form after a successful submission.
Client-side validation before Server Actions in Next.js
Server Actions do not replace client validation. Catch invalid form input early and prevent unhandled errors from becoming five hundred server error responses.
Type-Safe Adapter Registries with as const and satisfies
Learn how to replace hard-coded service calls with a type-safe adapter registry using TypeScript's as const, satisfies, and derived union types for safety.
Using Service Interfaces and Null Objects for Resilient TypeScript Scripts
How to combine service interfaces, factory functions, and the Null Object pattern to build TypeScript scripts that run without credentials or third-party deps.
Validating Multi-Provider Credentials with Zod Discriminated Unions
How to use Zod's discriminatedUnion to validate per-platform credentials, with a runtime-injected discriminant and TypeScript narrowing at call sites.
paulund/ai v3.1.0 - Writing Humanizer skill
Version 3.1.0 adds a dedicated Writing Humanizer skill to the paulundai collection, giving Claude Code a way to strip AI-generated patterns from text.
Building a URL Shortener with Next.js
How to design the data model, slug generator, and IP hashing for a short-link service using Prisma, Web Crypto, and HMAC-SHA256 for anonymised click tracking.
Magic Link Authentication in Next.js
How to build passwordless sign-in with email magic links using Supabase Auth, a React Email template, and a clean service wrapper around the OTP flow.
API Key Management in Next.js
How to generate, hash, store, and revoke API keys in a Next.js app using SHA-256 hashing, server actions, and cross-project guards for secure access control.
paulund/ai v3.0.0 - Skills-only layout and new planning skills
Version 3.0.0 removes the Claude plugin system for a flat skills directory and adds plan, ship, and several developer workflow skills to the collection.
Transactional Email with Resend and React Email
How to build a mailer module that renders React Email templates and sends through Resend, with test-time capture so you never send real emails from CI.
Type Annotations vs Type Inference: When to Write the Type
TypeScript can infer most types on its own, but knowing when to add an explicit annotation anyway is what separates readable code from a sea of colons.
The Compound Component Pattern in React
Learn how the compound component pattern lets you build flexible and composable React UI components that share state without prop drilling or complex APIs.
The Render Prop Pattern in React
How the render prop pattern lets you share behaviour between components, why hooks mostly replaced it, and the cases where render props still earn their keep.
useReducer for Complex State
Learn when and how to use useReducer in React to manage complex component state that has multiple related values or state transitions depending on each other.
The React Context API: Shared State Without a Library
Learn how to use React's built-in Context API to share state across components without prop drilling or reaching for a third-party state management library.
Dynamic OG Images in Next.js with opengraph-image.tsx
How to generate a unique Open Graph image per page at build time using Next.js App Router's opengraph-image.tsx convention, with static export support.
Lifting State Up in React
When two components need to share state, you move it to their closest common ancestor. Here is what that looks like in practice and why the pattern works.
Conditional Rendering Patterns in React
A practical look at the different ways to conditionally render content in React, covering when to use each pattern and which approaches you should avoid.
Lists and Keys in React: Why They Actually Matter
React keys do more than silence console warnings. Understanding how React uses keys during reconciliation reveals why the wrong key introduces subtle bugs.