A reading list for AI-augmented development
A small, opinionated reading list for engineers who want to go deeper into AI-augmented development. Annotated with personal notes on why each one matters and where to start. Not exhaustive — just the things I'd recommend to someone asking me where to begin.
The tools we build shape how we think
I started building AI tooling expecting it to make me faster. It did. What I didn't expect was that, three months in, I'd be approaching unfamiliar problems with a different mental shape than I had before. The tools changed the work, and the changed work changed how I think about work. That second loop is the more interesting one.
What I haven't learned yet
After writing a lot of confident-sounding posts about AI tooling, here's the inventory of what I'm still confused about. MCP servers I haven't really used. LangGraph patterns I copied without fully understanding. Prompt engineering subtleties I keep getting wrong. If you know any of this better than I do, I want to learn from you.
The compound effect of AI tooling
Each piece — rules, skills, subagents, journaling — is small on its own. The interesting thing is what happens when they layer. The system stops feeling like a collection of tools and starts feeling like an environment that was shaped to fit me. That shift is the compound effect, and it's the part nobody talks about.
From daily notes to stakeholder reports
One week's worth of journal entries serves four audiences, with four different lenses. The manager wants outcomes and risks. The team wants what's in flight. The reviewer wants edge cases. You want patterns. Here's why one source plus four lenses works better than four separate trackers.
Vendor-agnostic AI tooling — portable skills across coding agents
One canonical source folder. Symlinks from each tool's expected directory back to that source. The same skill files work in Cursor, Claude Code, and any other AI coding agent without forks. Here's the layout, the sync logic, and why locking your skill library into one tool is a mistake worth avoiding.
AI-powered engineering workflows
An AI assistant doesn't replace the daily capture/plan/report cycle most working engineers run. It changes the friction. The work that used to take an hour at the end of the day takes five minutes. What AI does well, and what still needs human judgment, are different in ways worth naming explicitly.
Wiring a journal agent with Slack
A journal agent that reads from your team's Slack channels for context and posts polished updates back is a small Python wrapper plus a few well-named bot tokens. This is the actual integration — token setup, conversations.history, posting receipts, channel aliases, and the small choices that keep the whole thing safe to run.
Why every engineer should keep a journal
Most engineers don't keep a journal. The ones I most respect, do. Some on paper, some in plain text, some inside an AI-augmented system. Different tools, same compounding benefits — memory, accountability, self-awareness, communication. Here's the case, regardless of how you do it.
When your AI writes 200 lines and it could be 50
The single most common failure mode I see with AI-generated code is overengineering. Not bad code — just too much of it. This post is a tour of the specific shapes that overengineering takes, before/after diffs from real sessions, and the one-line mental check that fixes most of it.
Behavioral guardrails for AI coding assistants
There are four behaviors I want any AI coding agent to follow, regardless of what model is behind it. Think before coding. Keep it simple. Make surgical changes. Define what done means. Each one came from a real mistake I watched the agent make. Here's why I encoded them as a rule file.
Org-wide standards as code
One standards repo, one wrapper that turns those standards into AI-agent rules, skills, and a security-review subagent. Add the wrapper as a workspace folder next to any project and the agent automatically follows the policy. Here's the pattern, the folder layout, and why this beats per-project copies.
A read-only AI security reviewer
A subagent that reads your security rules, looks at the code you just wrote, and tells you what's wrong by severity — with citations. This is the actual definition file, the rule set it consults, the output it produces, and the small choices that make it useful instead of a noise generator.
Subagents — specialized AI that doesn't pollute your context
Asking your main AI agent to do a heavy analysis task burns context you can never get back. Subagents are how you spawn a fresh, scoped, sometimes read-only AI instance to do that work — and hand back only the answer, not the noise. Here's the model, and when to reach for it.
Building debug skills that inspect live systems
A debug skill turns "let me crack open the database and see what the agent thought it was doing" into a thirty-second question to your AI agent. This is a walkthrough of one — start to finish — with the actual layout I use, the gotchas, and the small decisions that decide whether the skill is genuinely useful or just visible noise.
A taxonomy of AI agent skills
After writing thirty-three skills, a structure emerged. Six types. A naming convention that the agent itself uses to find the right one. This is the taxonomy I landed on, why each type exists, and the small design decisions that made the whole drawer easier to navigate.
AI agent skills — why I wrote 33 of them
I started with one. A small Markdown file with a few shell commands inside, that the agent could pull up by name. Two months later there were thirty-three. Here's the story of how the skill drawer filled up, and why it kept paying for itself.
Rules as project memory
AI coding agents start every conversation with no memory. Rules are the small Markdown files that fix that — they tell the agent the conventions of your project, attached to the right files at the right time. Here's how they work and how I think about writing them.
Authorship tags — being honest about who wrote what
I added authorship tags to every post on this blog — human-written, ai-assisted, or ai-generated. The categorization itself was harder than the implementation. Here's what I think the labels actually mean, and why declaring them feels less optional than it used to.
Teaching AI how to write like me
My blog has a voice. The AI doesn't, by default — it has the voice of the entire internet averaged together. So I wrote three rule files that teach the agent how I sound, what to avoid, and what counts as "done."
Planning 20 blog posts with an AI agent
I sat down with an AI coding agent to plan a 21-post series. I didn't expect the planning itself to be the most interesting part — but it was, and most of what I learned is about how to use these tools, not about what to write.
From writing code to designing intelligence
AI at work is often framed as a productivity hack or a risk — a convenient reduction of something structural. Here’s a sharper read on what’s changing, what broke when I pushed into unfamiliar territory, and why human validation still drew the line.
Multi-language support, at last
The very first item on my 2018 feature wishlist was internationalization. Eight years later, it's finally here — and every post now has a Portuguese translation.
Drawing a user flow graph with D3.js Sankey and React
Using Sankey diagrams to document software behavior, where each variation in user flow creates branches downstream.
Search and archive pages, finally
The search and archive pages that have been placeholders since 2018 are now real. Here's how they were built — and what it's like to direct an AI through UI work.
Back from the future, with AI
After years away, I'm reviving this blog with the help of AI — and the entire tech stack got a fresh start.
Content creation planning with Kanban
Ideas are much faster than actions, take notes and manage them later to become great articles.
Render web animations with React Lottie
How to render animations from Adobe After Effects using Bodymovin/Lottie and React web.
Integrate Google Analytics with React Router v4
Single-page applications requires especial treatment for tracking statistics on each page view.
The active listening
The most powerful groups are made with people who knows the time to talk and the time to listen.
Markdown renderer component that can render other React components
Markdown contents just got really really better!
My GraphQL studies
Just a log of my GraphQL studies.
My "Hello World" projects
Keeping up to date on IT can be a great challenge, having study systems comes very handy.
Component styles isolation: Concentric CSS
A thoughtful way to write CSS properties.
Creating React component with Markdown renderer and code syntax highlight
Given a Markdown string, then render as HTML with fancy code syntax highlight.
Component styles isolation: Dealing with CSS inheritance
How to ensure visual consistency with UI components usages.
How to fix custom domain overwriting problem when using gh-pages deploy script
Sometimes little changes can put down an entire website, luckily sometimes the fix is easy!
How to include a sitemap.xml in a create-react-app site
Creating a sitemap.xml generation with Babel and Node.
Categories and better typography
Content can now be fetched by category and the visual got some polishing for better readability.
Inject Google Analytics tag manager in a Meteor app
Instructions about how to easily inject GA tag manager in a Meteor app.
Redesign and better typography
Fourth day on this site's development, a blog for reading must be nice to read.
Fetching from Instagram using Facebook Graph API
Instagram API is being deprecated and from now will be using Facebook Graph API.
Comments section using Disqus and React
New feature included, opening channel for feedbacks!
Opportunity cost
For each opportunity we take, there are a ton of others we let pass.
Blog progress
Second day developing this project, long road ahead.
Custom boilerplate generators
This site have some custom made boilerplate generators that makes life easier.
Hello World
Hi there, in this post I explain briefly how this website was made.