The signal, not the noise.

Idempotency: how to prevent duplicate operations in APIs and distributed systems

Idempotency in APIs: prevent duplicate operations from repeated clicks, offline queues, duplicate webhooks, retries, and events in 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

Git and GitHub for beginners: from clone to your first Pull Request

A hands-on Git and GitHub guide for beginners: clone (or fork) a project, create your branch, commit, open your first Pull Request, request a review and merge.

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

From feudalism to AI: how to read past revolutions

AI revolution: understand how feudalism, empires, and industry changed scarcity, power, and work so you can decide better now.

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: how AI agents work without you piloting every step

Loop engineering turns prompts into cycles with goals, state, verifiers, and limits. Learn when agent loops help teams and when they burn expensive tokens.

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

What agentic AI means: the autonomous car reread

Agentic AI is autonomy with human judgment. Learn the difference from AI-assisted systems through the autonomous car metaphor.

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?

The web system bottleneck is rarely CPU. It is I/O

Understand why web systems slow down more from I/O than CPU, and how Node.js with TypeScript reduces latency without premature architecture.

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

Where Java with Spring Boot still beats Node.js (and where it doesn't)

It is not Java vs Node in the abstract. It is about where the maturity of the Spring ecosystem solves the boring production problems out of the box, the ones Node still puts together piece by piece, and where Node + TypeScript stay the obvious call. With honesty about Virtual Threads, types that vanish at runtime, and what really decides: the requirement.

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

MCP vs CLI: what each is, when to use them and when not to

MCP (Model Context Protocol) standardizes how AI apps discover and use external tools. But not every agent needs MCP — a plain CLI often wins on cost and speed. I walk through what MCP is, the client → server flow, real use cases, when it's overkill, and why CLI beats MCP for popular tooling.

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

llama.cpp hits 100k stars: the local agents era has begun

Why llama.cpp's milestone and Pi running Qwen3.6 on a MacBook in airplane mode mark the start of the second AI revolution — local, sovereign, and plural.

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

What is an agent, actually?

An honest definition of AI agents, distilled from Chip Huyen, Anthropic, and Cedric Chee: perception plus action in an environment, with tools, memory, and a decision loop.

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)

GoodAIList: the living map of open-source AI repositories

Why Chip Huyen's GoodAIList became my go-to lens for tracking the open-source AI ecosystem — and how to actually use it.

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)

LLM Wiki: Karpathy's Idea for Real Memory in AI Agents

Karpathy proposed swapping RAG for a persistent wiki that the LLM maintains on its own. Why it reframes the agent memory debate, and what Fabio Akita adds about the practical side.

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

The new visual identity of my website and blog: Futurist Minimalism + Agentic AI

The rationale behind the redesign: palette, typography, visual primitives, and engineering decisions to make the website more distinctive, modern, and alive.

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

Git Worktree: The Standard for Juggling Multiple Features and Running Agents in Parallel

Many working trees, one repository. How git worktree kills destructive context switching, runs multiple AI agents in parallel, and why it beats cloning the repo by hand.

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

How to Add Blurred Text in React Native

A stylish way to hide information in your React Native app using BlurView.

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 Validate US Shipping Addresses with JavaScript and React

Two approaches to validate US shipping addresses: Google Maps Geocoding API and client-side validation with React Hook Form + Zod.

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

Web3 - What to build?

Know about what kind of solutions you can build using web3 technology

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

Basic Wax blockchain

Useful links, sample code about how to interact with

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

My First Next Level Week at Rocketseat

Impressions and reflections on Rocketseat's Next Level Week

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

Introduction to GraphQL with NodeJS and MongoDB

Get started with GraphQL on a Node.js backend backed by MongoDB — schema, resolvers, queries and mutations from scratch.

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

React Hooks + Redux (useSelector) + Unform

Boosting productivity with React Hooks + Redux (useSelector) and 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

Using react-native-vector-icons in React Native - iOS

How to install and use react-native-vector-icons on iOS with React Native 0.61+ (autolinking).

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

Creating a Node.js project

See how easy it is to bootstrap a Node.js project in Visual Studio Code

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

Higher-Order Function with Reduce

Higher-Order Function with Reduce — Recompose's Compose explained

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 Node.js via binary archive on Linux?

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

Importing and exporting files in MongoDB with Meteor

Import/Export files in MongoDB using Meteor to handle the import flow

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

A logic book with OO in Java

Reading tip: Applying Object-Oriented Logic in Java

Emulating your apps directly from the phone

Emulating your apps directly from the phone

PostgreSQL Course

Handbook for a PostgreSQL course