berk.ai

Toolbox

My Toolbox

Over the years, I’ve refined a development workflow centered around a carefully selected set of tools, platforms, and technologies. My goal isn’t to chase every new framework—it’s to assemble a toolbox that lets me move quickly from an idea to a production-ready product while maintaining quality, reliability, and a great developer experience.

I constantly evaluate new technologies, but only adopt them when they meaningfully improve the way I build software. The result is a modern, AI-first engineering workflow that allows me to prototype in hours, iterate in days, and ship production systems with confidence.

Rather than viewing AI as a feature, I treat it as an integral part of my engineering process—from architecture and implementation to testing, documentation, deployment, and ongoing maintenance.

  1. 01

    Think

    Frame the problem, explore the domain, challenge assumptions, and make the architecture legible before implementation hardens it.

    ChatGPT

    A thinking partner for exploring a problem from several angles and turning loose ideas into testable plans.

    OpenAI Platform

    The place I prototype model behavior, structured outputs, tools, and multimodal interactions before product integration.

    Jupyter Notebooks

    A low-friction workspace for inspecting data, testing model behavior, and making experiments reproducible.

    Also in this stage

    • Codex
  2. 02

    Build

    Move quickly from a vertical slice to a maintainable product with strong types, composable interfaces, and short feedback loops.

    Cursor

    The environment where nearly all new ideas become working software.

    Claude Code

    Useful for sustained implementation, codebase exploration, and independent review of complex changes.

    Also in this stage

    • Next.js
    • React
    • TypeScript
    • Kotlin
    • Ruby
    • Ruby on Rails
    • AI SDK
    • Drizzle ORM
    • Better Auth
    • Tailwind CSS
    • Radix
    • shadcn/ui
    • Node.js
  3. 03

    Run

    Keep local development close to production while preserving the freedom to experiment with models, data, and background services.

    Docker

    Keeps databases and service dependencies reproducible without making local iteration feel remote.

    Ollama

    The fastest path to evaluating and integrating local models behind a simple interface.

    LM Studio

    A visual workbench for comparing local models and understanding their behavior before wiring them into a system.

    OpenClaw

    The self-hosted agent runtime behind my personal multi-agent research and automation experiments.

    Also in this stage

    • Postgres
    • Redis
    • Tailscale
    • Git
    • macOS
    • Homebrew
  4. 04

    Deploy

    Choose the smallest operational surface that fits the workload, from server-rendered products to continuously running workers and distributed platforms.

    Vercel

    My default for shipping modern web products with preview environments and very little deployment ceremony.

    Fly.io

    My preferred platform for continuously running background workers.

    Neon

    My default Postgres provider for modern cloud-native products.

    Also in this stage

    • AWS
    • Google Cloud Platform
    • Kubernetes
    • GitHub
    • Cloud Object Storage
  5. 05

    Operate

    Observe real behavior, learn from users, and keep product, engineering, and communication in the same feedback loop.

    Datadog

    The operational view I reach for when traces, logs, infrastructure, and application behavior need to tell one story.

    PostHog

    Connects product decisions to what users actually do without separating analytics from iteration.

    Linear

    Keeps planning lightweight enough that the work stays visible without the process becoming the work.

    Resend

    A focused email platform with an API and developer experience that fit product teams.

Engineering Philosophy

My toolbox is intentionally opinionated.

I prefer technologies that are simple, composable, and well documented. I value developer experience just as highly as runtime performance, because great products are built by teams that can iterate quickly.

When evaluating new tools, I look for:

  • Excellent developer experience
  • Strong type safety
  • First-class AI integration
  • Production reliability
  • Fast local development
  • Clear documentation
  • Vibrant communities
  • Minimal operational complexity

The specific tools in my toolbox will continue to evolve, but the philosophy remains the same: choose technologies that remove friction, encourage experimentation, and allow great ideas to become working software as quickly as possible.