Gears

Primary editor for the portfolio, TypeScript, MDX, and most day-to-day implementation work. Fast enough to stay in the flow, flexible enough for the messy parts.

Used when Python projects need stronger navigation, debugging, refactoring, and less guesswork than a lightweight editor gives me.

AI-assisted editor for fast prototyping, codebase exploration, and rough feature scaffolding. Useful, but I still treat generated code as guilty until reviewed.

Agent-first IDE for experiments where I want the agent to plan, execute, and verify larger coding tasks instead of only completing the next line.

Source control, project history, public proof of work, and the place where unfinished ideas eventually have to become real commits.

Notebook environment for EDA, model experiments, charts, sanity checks, and turning vague ML ideas into measurable evidence.

Used as a coding partner, technical sparring tool, draft generator, and API exploration surface. Helpful for speed, dangerous if I stop verifying.

Strong for reasoning-heavy writing, architecture critique, long-context code review, and pressure-testing whether an idea actually makes sense.

Inline assistance for boilerplate, predictable refactors, and staying inside the editor when the shape of the solution is already clear.

Research assistant when I need citations, source trails, and a faster way to compare claims before trusting them.

Model discovery, dataset exploration, papers-to-code research, and Spaces when a quick ML demo needs to be visible instead of buried in a notebook.

First-pass architecture sketches, thesis diagrams, product flows, and anything that needs to be understood before it is polished.

Default language for ML, automation, data work, API experiments, and the glue code around serious technical projects.

Deep learning framework I reach for when experiments need flexibility, debuggability, and a clean path from idea to training loop.

Classical ML workhorse for preprocessing, baselines, metrics, model comparison, and proving whether a deep model is actually necessary.

RAG orchestration layer for retrieval, chunking, prompt assembly, and grounding answers in source material instead of vibes.

Experiment tracking, model registry thinking, run comparison, and the difference between 'it worked once' and evidence you can defend.

Streaming backbone for production-style ML pipelines, especially when inference needs to look more like a system than a script.

Workflow orchestration for batch ML pipelines, scheduled retraining, and making data movement visible instead of magical.

Containerization for reproducible local runs, demos, APIs, and deployment paths that do not depend on someone's laptop being configured perfectly.

Main full-stack React framework for the portfolio and product-facing web apps. App Router, server components, metadata, API routes, and deployment fit the way I build.

Strict mode by default. Types are not decoration; they are cheap leverage against future bugs and unclear contracts.

Backend API layer for ML systems, RAG services, and data-heavy prototypes where Python needs to serve real users.

Styling system for fast, precise interfaces. Works well when the goal is a real product surface, not a generic template.

Deployment target for Next.js work where speed, preview URLs, and production ergonomics matter more than server maintenance.

Postgres-backed product backend for auth, storage, realtime features, and prototypes that should not start with weeks of infrastructure work.

Automation for linting, type checks, builds, tests, releases, and the boring checks that catch avoidable mistakes before users do.

Primary interface design tool for product screens, component systems, visual direction, and turning technical ideas into something people can understand.

Fast visual production for thumbnails, social assets, simple decks, and content that needs to ship before it becomes overdesigned.

Text-based diagrams for architecture, flows, and project pages where the diagram should live close to the code and docs.

Palette exploration and contrast checks when a project needs a visual identity without wasting a week pretending colors are strategy.

Planning, research notes, product thinking, and long-running project context. Good for strategy; dangerous if notes become a substitute for shipping.

Issue tracking model I prefer for serious product work: clear priorities, small scopes, and less ceremony than heavyweight PM tools.

Local-first thinking space for notes that should remain portable, searchable, and independent from whichever platform is trendy this year.

Background audio for long work blocks. Nothing mystical here: focus is fragile, and silence is not always available.

Async walkthroughs for demos, design reviews, bug explanations, and showing the actual thing instead of writing five paragraphs around it.

API testing, request collections, auth flow checks, and quick validation before blaming the frontend for a backend problem.

Database inspection when SQL needs to be seen clearly: schemas, rows, quick checks, and debugging data issues without ceremony.

DNS, CDN, and edge tooling for web projects. Useful infrastructure when speed and control matter, but not something to overcomplicate early.

Image hosting and transformations for portfolio assets, avatars, and responsive media without hand-rolling every optimization path.

Transactional email for contact flows, confirmations, and newsletter-style product surfaces where email has to work quietly.