The signal, not the noise.
Long-form essays and rapid field notes on AI agents, product engineering, careers, and the craft of shipping.
What is Jev? Structured AI decisions for software
Jev is TypeSafe's System One model for structured software decisions. Learn its typed primitives through a safe customer refund triage example in production.
LLM vs inference: the model is one thing, execution is another
LLM vs inference: learn why the LLM is the trained model, while inference is the execution that runs the model to generate answers, costs, and latency.
What is the N+1 query problem?
N+1 query problem: learn why one page sends too many database queries, how to spot the pattern, and fix it with joins, preload, or batch loading in APIs.
How to create an agentic portrait particle reveal
Agentic portrait particle reveal: learn how to create a Canvas 2D brush with typed arrays, local reveal, lazy loading, and a demo video.
DDL vs DML: database structure and database data
DDL vs DML: learn the difference between SQL commands that define database structure and commands that read, insert, update, or delete data with examples.
Why Docker Sandboxes matter in the agentic era
AXI: 10 principles for agent interfaces
AXI changes how developer tools should talk to agents: apply 10 principles to reduce tokens, avoid rework, and make CLIs reliable in real projects.
Data modeling in real systems: relationships, reports, and scale
Data modeling in real systems: decide FKs, joins, reports, snapshots, sharding, and separate databases before growth turns into operational chaos at scale.
Data modeling: when to normalize and when to stay flexible
Data modeling: decide when to tighten schema, keep fields flexible, and separate CRUD, dashboards, and reports using cardinality and real access patterns.
IndexedDB vs localStorage: where to store data in an offline-first app
IndexedDB vs localStorage in offline-first apps: see when to use Dexie, where localStorage fits, and why operational data belongs in the app's localDB.
Idempotency: how to prevent duplicate operations in APIs and distributed systems
useEffect vs useLayoutEffect: when to use them and when to delete the Effect
useEffect vs useLayoutEffect in React: learn when to sync external systems, measure layout before paint, and delete needless Effects safely.
Agentic Git: how to use AI to work with Git and GitHub (without burning tokens)
An Agentic Git guide for vibe coders and junior devs: let the AI agent create branches, commits, PRs and resolve conflicts using the git CLI (not an MCP) to save tokens.
PgBouncer connection multiplexing, and how Neon does it
How PgBouncer multiplexing lets thousands of clients share a few Postgres connections in transaction mode, and how Neon builds it in with a serverless driver.
How database connection pooling works
How database connection pooling works: a pool keeps a few connections open and lends one per query, avoiding the cost of opening a connection on every request.
Git and GitHub for beginners: from clone to your first Pull Request
DDD with EventStorming in iTOP: from ticket sale to check-in
Learn DDD in a familiar ticketing domain: events, orders, payments, ticket issuance, check-in, subdomains, bounded contexts, rules and TypeScript.
DDD in practice with EventStorming: from client intake to the first lawsuit
Understand DDD through a legal domain: domain, subdomains, bounded context, aggregate, business rules, EventStorming and simple TypeScript code.
How to use the Domain-Driven Design starter modelling process
Domain-Driven Design gets clearer when a team turns business goals, domain knowledge, architecture, team design and code into one process it can repeat.
Products were automation before software
Automation before software: understand how products, services, and technology packaged processes long before AI.
From feudalism to AI: how to read past revolutions
The market became an AI experiment
AI in the market: understand the chaos, layoffs, marketing, new opportunities, and pressure on people in 2026 and 2027.
Node.js AsyncLocalStorage: async context without prop drilling
Node.js AsyncLocalStorage carries request context across async code. Learn implementation, use cases, maintainability, and multi-tenancy patterns.
Superpowers vs Agent Skills vs Matt Pocock's Skills
Superpowers vs Agent Skills vs Matt Pocock's Skills: compare autonomy, lifecycle coverage, and daily tooling to choose coding-agent skills with less risk.
Loop Engineering: what it is, where to use it, and when to avoid it
Loop Engineering applies AI agents in cycles with goals, memory, verification, and limits. See where to use it in product, coding, and daily life routines.
Loop Engineering: how AI agents work without you piloting every step
Cognitive distortions for engineers: how to think better under pressure
Cognitive distortions affect technical decisions. Learn common patterns and replace automatic reactions with clearer evidence under pressure in day-to-day work.
HTTP QUERY: the safe method with a body is now RFC 10008
HTTP QUERY is now RFC 10008: learn when to use the safe method with a body, how it differs from GET and POST, and what to check before shipping in real APIs.
How I added browser-native TTS to the blog
Browser TTS tutorial for Next.js blog posts: research Web Speech API, plan the player, implement voices, speed control, tests, ship notes, and next steps.
REST vs RPC: when to use gRPC, tRPC, oRPC, or REST
REST vs RPC: compare performance, OpenAPI, typed errors, streaming, and DX to choose between REST APIs, gRPC, tRPC, and oRPC in real production systems.
What agentic AI means: the autonomous car reread
How software development changed in 2026
Software development in 2026 changed with agents, specs, skills, MCPs, and automated QA, but the fundamentals stayed the same.
How I built Ask Thiago: a public RAG for my blog
Ask Thiago shows how to ship a public blog RAG with published content, cited sources, search fallback, optional AI Gateway, and safe feature flag rollout.
Beginners should not start with JavaScript
JavaScript for beginners feels easy, but it teaches risky habits early. Start with compiler feedback, types and immutability before scaling real codebases.
Sandcastle vs Flue: coding agent runner or agent framework?
Sandcastle vs Flue: compare function, sandboxing, Git, sessions, workflows, and deploy to choose a coding agent runner or agent framework.
The web system bottleneck is rarely CPU. It is I/O
Code review process: how to review code without blocking the team
Code review process improves quality without blocking the team: prepare small PRs, review risk, separate blockers from suggestions, and keep a clear flow.
Deploy cancelled by Out Of Memory: WiredTiger cache in containers
A Dokploy deploy stopped during the Next.js build and was cancelled without a clear error. The cause was memory pressure: two MongoDB instances in containers calculated their WiredTiger cache from the VPS RAM, not from an isolated container limit.
RPC, REST and GraphQL: the same remote call with different interfaces
In a fullstack TypeScript web app, REST, GraphQL and RPC/tRPC look like three different worlds. But all three serialize data, send it over HTTP and read the response back. They all live on OSI layer 7. What changes is not how remote the call is, it is the mental interface at the top, and the price each abstraction charges. With the tRPC vs Server Action contrast on the same create.
The harness is the product
WorkOS, Stripe, and OpenAI arrived, through different paths, at the same conclusion about coding agents: senior engineering stopped being about writing code and became about building the harness that makes the agent write code reliably.
Where Java with Spring Boot still beats Node.js (and where it doesn't)
Back to the fundamentals: I'm taking Andrew Ng's Machine Learning Specialization
Why, after spending every day building with LLMs and agents, I decided to go back to classic ML basics — and what each of the three courses in Andrew Ng's specialization actually covers.
LlamaIndex: orchestrating your data with LLMs
How LlamaIndex solves the problem of connecting private data to language models — from ingestion to RAG, agents, and query engines.
14 books every engineer should read — and the core lesson of each
Chip Huyen's non-technical reading list, with a summary and the practical takeaway from each book: from complex systems to cryptography, by way of chance, design, and scientific ethics.
Anatomy of an agent: what tools really are
Starting from Chip Huyen's agents essay and reading the code of an open-source coding agent, we unpack what a tool is, how the model calls it, and why defensive prompt engineering isn't optional.
MCP vs CLI: what each is, when to use them and when not to
My AI journey: from ChatGPT in 2023 to the creative chaos of 2026
How I went from a question-and-answer chat box to an entire agent-driven development workflow — Cursor, Claude Code, Pi.dev, Conductor — and why 2026 is the year to rebuild how we code.
Why Markdown is the lingua franca of LLMs and what it changes for your RAG
Markdown is not just a human-friendly format — it's the syntax LLMs were trained on at scale. Why it improves table understanding, chunking, and RAG quality — and where the claim deserves nuance.
Conductor: orchestrating multiple AI agents on Mac without the mess
My experience using Conductor to run Claude Code and Codex in parallel inside isolated workspaces, with git worktrees, diff viewer, and merge — without ever opening GitHub.
Reasoning Is Planning: how RAP changes the way LLMs think
How the RAP framework (Reasoning via Planning) turns an LLM into both agent and world model, then uses Monte Carlo Tree Search to unlock deliberate planning — beating GPT-4 + CoT on Blocksworld with just LLaMA-33B.
llama.cpp hits 100k stars: the local agents era has begun
Lenis in Next.js: how 19 lines turned the site's scroll cinematic
The site's scroll was native, hard, with that 'step-step-step' feel on long pages. I dropped in Lenis via ReactLenis root and it locked into the rest of the redesign without hijacking the page, without breaking anchors, and without fighting prefers-reduced-motion.
In 2026, use Postgres — until requirements say otherwise
Consolidating Elasticsearch, Redis, Pinecone, Kafka, and MongoDB into Postgres is the right bet for most teams — the AI-agent era only reinforces it. But honestly: where Postgres shines, where it hits a wall (CAP, sharding, replication), what to use for a distributed banking core (CockroachDB, Spanner, MongoDB, Cassandra), and why it all starts with requirements.
How to build a GenAI platform: a 7-layer tutorial
A practical walk-through to evolve a generative AI app — from a single model call to a full platform with RAG, guardrails, gateway, cache, agents, observability, and orchestration. Based on Chip Huyen's essay.
Why Python and PyTorch dominate ML inference
Python is the glue language, PyTorch won on eager mode, and almost no one serves raw PyTorch in production. The rationale behind today's default ML stack.
What is an agent, actually?
RAG end to end: Input, Retriever, and Generator explained
A dense overview of RAG (Retrieval-Augmented Generation): what it is, why it matters, what Retrieval, Augmented, and Generation mean, the offline ingestion pipeline, the online query flow, embeddings, cosine similarity, HNSW, and chunking.
The AI Engineering Stack: an applied summary
What changes when AI engineering stops being ML engineering: the three layers of the stack, why product now comes before model, and where the real complexity moved.
Pinecone: the default vector database for RAG
What Pinecone is, when it makes sense, how it works, and the trade-offs against pgvector, Qdrant, Turbopuffer, and Upstash Vector.
pgvector + Aurora PostgreSQL for embeddings: why I picked it (and how I use it)
The rationale for choosing Aurora PostgreSQL with pgvector over a dedicated vector database, plus a hands-on setup, indexing, and query guide using Drizzle.
GoodAIList: the living map of open-source AI repositories
6 common pitfalls when building generative AI applications
Notes and commentary on Chip Huyen's essay — the predictable mistakes teams make when moving from LLM prototype to production.
Leaving the cloud: why 2026 is the year of the bare metal comeback
Cloud repatriation stopped being a Twitter take and became a real movement. The rationale behind moving back to bare metal, the numbers that matter, and when it actually makes sense for your team.
AI stack trends across 7 companies: what The Pragmatic Engineer actually shows
AWS Bedrock, Postgres with pgvector, LangChain, and the move down to the metal: the useful read isn't the list of tools — it's the curve they trace.
PRD vs SPEC: which one to write first (and why with AI it matters more)
The practical difference between a Product Requirements Document and a Technical Specification, the natural flow between them, and why skipping the PRD in the AI era is the fastest path to shipping the wrong thing.
LLM Wiki: Karpathy's Idea for Real Memory in AI Agents
What would the best programming language for AI agents be?
Akita asked the uncomfortable question: what if the ideal language were built for LLMs to edit, not for humans to read? My bet is the answer is not a new exotic language, but gradual contracts on top of something models already write well.
Volumetric light, fog rings and 3D parallax: rebuilding the hero in pure CSS/SVG
Five techniques used to redesign the home hero — Grok-style volumetric beam, dissolved photo edges, organic fog ring, mouse-driven 3D tilt, and AI background removal — taught both as prompts and as code.
The MacBook and the minimalist distro: why 2026 is the year to test AI tools
A reply to Akita about oh-my-pi and OpenCode. The Linux analogy works — but maybe Claude Code is the MacBook, and Pi is the minimalist distro you admire but can't keep maintaining.
I fear regret more than failure
A personal reflection on leaving stability, pursuing an international tech career, and accepting that some decisions are still worth it even when they hurt.
The new visual identity of my website and blog: Futurist Minimalism + Agentic AI
Harness Engineering: what makes AI agents ship real software
Better models help, but the real quality leap in coding agents comes from the environment around them: context, sensors, memory, gates, and orchestration.
Software Developer/Engineer Career Levels
A practical guide to software engineering career levels, from junior to distinguished engineer, and the skills expected at each stage.
Imposter Syndrome in Tech
A reflection inspired by Julie Pagano's talk on insecurity, anxiety, confidence, and the invisible monsters that follow people through tech careers.
Agent Harness Engineering in practice
Why coding agent performance depends more on the harness than on the model alone, and how to apply that in day-to-day engineering.
Git Worktree: The Standard for Juggling Multiple Features and Running Agents in Parallel
Vibe Coding vs Agentic Engineering
A quick and simple look at the difference between vibe coding and agentic engineering.
Avoiding In-Memory Aggregation and Overfetching in MongoDB with Prisma
How we stopped loading entire collections into Node.js and let the database do its job.
Getting Started with Next.js 15
Learn how to build modern web applications with Next.js 15, the latest version with App Router and React Server Components.
TypeScript Tips for React Developers
Essential TypeScript patterns and tips that will make your React code more type-safe and maintainable.
How to Add Blurred Text in React Native
Organizing Your Backend: Services or Helpers?
The difference between services and helpers, and how to organize them in your backend folder structure.
Using for await...of to Iterate Sync and Async Arrays in JavaScript
How the for await...of loop simplifies async data handling, with practical examples.
Conventional Commits in Practice: Patterns for a Better Git History
Hands-on guide to writing better commit messages with Conventional Commits — types, scope, examples, and a cheat sheet.
AbortController: Manage Memory Efficiently in React
How to use AbortController to cancel fetch requests and prevent memory leaks in React components.
How to Validate US Shipping Addresses with JavaScript and React
Sharing Env Vars in a Monorepo with Vite and Next.js
Keep a single .env.shared at the root of your monorepo and generate per-app .env files with the right Vite and Next.js prefixes.
How to Learn Quick
Study techniques and habits to accelerate your learning — without falling for the illusion that you can learn everything in a few days.
What Is Technical Debt?
What technical debt is, when it happens, and how to manage it so it doesn't drag your software down.
How to create a custom random ID with Postgres
Helper function for creating a custom random ID like a9Kl12
Web3 - What to build?
How to Deploy a Monorepo with TurboRepo on Heroku
Github + Monorepo + TurboRepo + Heroku
How to merge two or more repos into a new one without losing the history of commits
TurboRepo in Action
Becoming a fitness Dev
The Five Do's for good daily habits that you should begin today.
React Suspense - in the right way
Study case about how to use React Suspense
Basic Wax blockchain
How to get the first job
What I tell to my mentees - Tips to getting a Job
Using find with delete flag
Nice command Unix find.
Expansion Week at Rocketseat
To infinity and beyond — second edition of EW/RS
Understanding Falsy and Truthy values in JavaScript
Both concepts are very common and essential for JavaScript Developers. They are widely used in Back-end and Front-end Apps.
My First Next Level Week at Rocketseat
Renaming a Branch in Git
Commands to rename a local and remote branch in your git/GitHub repository
Types of Parameters in REST Requests
Conceptualizing and differentiating the types of request parameters in REST APIs.
Quick Tips about React Native
Some quick tips for React Native beginners and I recommend a nice podcast
How to install React Native with Typescript
I'll show how to install React Native with Typescript
Introduction to GraphQL with NodeJS and MongoDB
How to access Redis from inside Docker and run queries
Connect to a Redis container and inspect keys/values with the redis-cli
GoBarber - Mobile App with React Native
My class notes and code from the Rocketseat bootcamp, where we build a mobile app that consumes a Node.js API
Using react-native-vector-icons in React Native - ANDROID
How to set up and use react-native-vector-icons on Android in modern React Native projects
GoBarber Web - Frontend Application with React
My class notes and code from the Rocketseat bootcamp; in this project we build a frontend that consumes the GoBarber Node.js API
React Hooks + Redux (useSelector) + Unform
React and Redux Hooks API: a practical guide
Let's continue the GoBarber app and learn some advanced techniques and best practices.
Flux Architecture: A Rocketshoes E-commerce
Let's build a Rocketshoes e-commerce to learn Flux through a Redux implementation, using Redux Saga to handle side effects for asynchronous features
Meet Polished: a JS library for color manipulation
I really enjoyed lightening and darkening colors with the polished library — it pairs nicely with Styled Components for component styling.
Introduction to React Native
How to set up webpack, babel, and the CSS and image loaders, plus the main React lifecycle methods
Using react-native-vector-icons in React Native - iOS
First Project with ReactJS
Let's build an app with React and Styled Components that fetches a repository from GitHub, persists it to localStorage, and lets us view its GitHub issues.
Introduction to React
How to set up webpack, babel and the css/image loaders, plus the main React lifecycle methods
Continuing the GoBarber API
Let's continue the GoBarber application and learn some advanced techniques and best development practices.
GoBarber - Backend Application
My class notes and code from Rocketseat's bootcamp — in this project we build an API with NodeJS
Creating a Node.js project
Node.js Concepts
An overview of the Node environment, NPM, Yarn, the Event Loop, the Call Stack, and more
My Development Environment
A walkthrough of my hardware, IDE, extensions, terminal, plugins, fonts, theme, and tools for software development
Ignoring git status when file or folder permissions change in a git-versioned project
If someone runs chmod 777 -Rf * on a project directory or ...
How to keep your repository updated with main project
How to keep your repository updated with main project
Higher-Order Function with Reduce
Ten Rules for Achieving English Fluency
I read this ebook: 10 Rules for achieving English Fluency, and I really appreciate it. Then I wanna share with you ones, check it out:
High Order Functions — Easy Mode
I intend to explain a little bit about High Order Functions with Javascript.
Finding and Sorting Records by Date in Mongo with Meteor
A quick tip on Meteor's Mongo sort syntax and why it differs from the raw MongoDB query.
Downloading npm packages behind a proxy
How to install npm packages from inside a network with a proxy.
How to install Node.js via binary archive on Linux?
Help for learning English
A technique for internalizing English content
Practice Itself
Practice Itself — Starting to speak English — Baby Steps
Creating a Code Snippet in VSCode
See how easy it is to create a boilerplate in Visual Studio Code
Basics of Component Composition
Fundação Bradesco course, free online course
Importing and exporting files in MongoDB with Meteor
Reading Tip - JS Cangaceiro
Reading tip: Cangaceiro JavaScript, an adventure in the backlands of programming
Configuring a custom domain for GitHub Pages
A quick tutorial on how to host a static site on GitHub Pages and point a custom domain to it.
Computer Scientist
My graduation ceremony for the Bachelor's in Computer Science at Uniderp in Campo Grande/MS
Parallel Processing and Distributed Systems
chat_ppsd project — Parallel Processing and Distributed Systems
A logic book with OO in Java
Emulating your apps directly from the phone
Emulating your apps directly from the phone
PostgreSQL Course
Handbook for a PostgreSQL course