Stacklogs is a personal archive of software development stories, field notes, experiences, conversations and reflections.
Open source maintainers are drowning in pull requests and reports written by AI. This post gives the numbers I could read at the source, a four-week plan for beginners, a git walkthrough I really ran, a pull request template with an AI disclosure line and a self-check list.
An agent that runs while nobody watches needs to leave a trail. A beginner explanation with a shop CCTV picture: what to record, what never to record, a simple JSON Lines format, how to hide secrets and how to read the trail back to rebuild a timeline. Includes a script run for real on 25 actions.
Deleting an API key from your code is not the end: it stays in git history. A real experiment with fake keys, the right order when a key leaks (rotate first, clean later), how to block leaks with a pre-commit hook and .gitignore, and habits for working with AI agents.
AI coding is increasingly billed by the token. This post explains tokens with everyday pictures, why a long conversation gets more expensive with every turn, a script you can run to see it, and three ways to keep costs down: short sessions, cheaper models for routine work, caps and monitoring.
Feeling faster with AI is not the same as being faster. A guide to a small two-week self-experiment: randomize ten tasks, time the rework too, compare medians and read the result with humility. Includes a CSV template, a script that really runs and a worked example with answers.
One click travels through seven legs: address lookup, connection, security, the request, the application, the database and the reply. An explanation with a parcel picture, how to time each leg with curl, exercises with answer keys and the mix-ups to avoid when you ask AI to fix a slow page.
Reproduce, shrink, form a hypothesis, halve the search with git bisect, then verify: five steps you can do yourself, and how to hand AI a good bug report afterwards. With a real 20-commit practice repo, an answer key and a bug report template.
Why queries get slow, how to read a query plan, why column order matters in a multi-column index and when an index hurts. Every number comes from a real SQLite experiment with 100,000 rows, with a script you can rerun and exercises with an answer key.
Agents edit code very fast, and sometimes get it wrong very fast. This post explains Git with the picture of save points in a game: one branch per task, small commits, reading the diff before you accept, and safe ways to go back, with real output from a practice repository.
A small team does not need a thick rulebook. This post gives one page with three columns (allowed, ask first, forbidden), four data levels in plain words, who is accountable and what to do in an incident, with a paste-ready template, an example for a six-person team and a checklist.
One page that says why the team chose this way and not that one saves newcomers from asking again, and stops AI agents from quietly undoing old decisions. With a one-page template, an illustrated example, common failures and a checklist.
An AI agent does not have unlimited memory: everything it is working with sits on a desk of fixed size. An explanation with everyday pictures of why long conversations make an agent worse, when to clear, summarize or start over, with a worked calculation, a handoff template and a checklist.
Instead of re-checking everything AI does yourself, ask it to hand in evidence that is easy to check: sources you can open, a test you can run, small changes, a sort into ran, only read and assumed, and a way for someone else to rerun it. With sample prompts, a time calculation and a checklist you can use tomorrow.
Since 2025 some articles say AI is wiping out entry-level developer jobs and others say the opposite. This post lays the numbers side by side, explains why they disagree, gives six questions for reading any figure, and lists what a newcomer can do whichever side is right.
Learning with AI can be faster, but one study found the group that handed everything to the AI understood less. This article summarizes the evidence, states what is not known, and gives a four-week plan with AI-on and AI-off sessions and a self-test every Friday.
AI coding tools sometimes invent library names that do not exist, and attackers can register those exact names and hide malware in them. An explanation with everyday pictures, study numbers, real cases and install habits you can use tomorrow.
When an AI tool answers wrongly or breaks something, who carries it? This reflection goes through two real cases (Air Canada and Mata v. Avianca), draws a simple map of responsibility, and suggests five things a team can do now so that nobody blames the machine.
A successful AI feature is not only about how many people use it. This article proposes measuring three layers, quality, cost and trust, with a one-page board of nine metrics, a cost-per-successful-outcome formula that counts reviewer effort, a way to read acceptance rate without being fooled, and the usual traps.
On 28 February 2017, a command with one mistyped input removed more servers than intended from Amazon's S3 storage service and slowed or stopped many internet services for about four hours. This retelling follows AWS's own post-event summary and draws out the safeguards a tool with the power to remove should have.
AI writes the code and the tests for it, so a test easily just confirms the code it just wrote. This article explains why green tests are not enough, gives a 500-thousand boundary example, and seven ways to keep tests valuable: write from the spec, see red first, break the code yourself, mutation testing, property-based testing, boundary tables and a real run.
Often an AI agent builds something other than what you had in mind, or reports done when it is not. This article names seven common mistakes in writing requests, based on Anthropic's practice guide and real bugs from this very blog project, with before and after request templates and a five-question list before letting an agent run alone.
In one day this blog gained thirteen posts, twelve of them written with an AI agent. This article records the log and the numbers drawn from the git history and the chat history: 22 commits, more than 17 thousand changed lines, 47 human messages, and why the rate of bug reports fell sharply in the second half. With the limits of the numbers themselves.
Some companies now allow AI in coding interviews, some still ban it, and there is no shared standard. This article gives a two-week plan for anyone about to interview: ask for the rules, practice fundamentals without AI, practice reading and debugging, practice working with AI in a disciplined way, and prepare to answer questions about AI.
Many teams build AI features but few measure them. This article shows how to start by reading thirty real cases, sorting the failures, and only then writing evals, following Hamel Husain and Shreya Shankar's guide, with a logging sheet, a three-afternoon plan and common mistakes.
Spec-driven development means writing down what to build first, then letting AI work from it. This article explains the three levels, the tools Kiro, Spec Kit and Tessl as analyzed by Martin Fowler, when it pays off and when it does not, with a light five-part spec template you can use today.
The OWASP Top 10 for LLM applications (2025 edition) is hard to read for newcomers. This article explains each entry with the picture of an AI hotel receptionist, gives the mitigations from OWASP's own pages, and suggests a priority order and a ten-question checklist.
AI writes code faster, so many ask where the creative part of programming has gone. This reflection splits a developer's work into five layers, looks at which AI takes and which remain, sets it beside figures on enjoyment, skill and productivity, and names the risks and habits for keeping the craft.
On 31 January 2017 a GitLab engineer ran a delete command on the wrong server and lost about 300 GB of data. Then five layers of backups all failed. This retelling follows GitLab's own postmortem and ends with a checklist for the minute before you type a delete command.
A rebuilt coffee chat between Mai, a worried fresher, and Khoa, a senior. They speak plainly about fear of losing jobs, letting AI do the exercises, what to learn, who to ask, how seniors use AI and what employers look at, with evidence from studies.
MCP is a shared standard for AI apps to plug into tools and data, like one power socket for many appliances. This article explains it with the socket picture: the problem before MCP, the three things an MCP server offers, how it runs, the security risks and a checklist before plugging in.
Lines of code is the easiest number to count and the easiest to misread, especially when AI writes a thousand lines in seconds. This article explains why, tells the minus-2000-lines story, and offers team-level replacement metrics and how to use them without harm.
Instead of passing work through many stations, many IT teams are heading toward small crews that work with AI assistants. Told through a little bakery, with real numbers, examples from work, and the traps of the new way.
Vibe coding can give you a working prototype in a day, and also a fast route to security holes and technical debt. This article says when to use it, when to stop, a one-day plan and a checklist before a prototype becomes a product.
Entry-level hiring is tougher and AI writes much simple code. This article gives a 12-month plan in four quarters, how to use AI to learn instead of being learned for, weekly habits and a way to check your own progress.
AGENTS.md or CLAUDE.md is a file that briefs AI about your project. This article explains what it is, two studies with opposite results, six sections worth having, good and bad examples, a template to copy and how to keep the file accurate, with a real example from this very project.
AI writes code fast, so the bottleneck moves to review. This article gives a 15-point checklist in four groups, each point with warning signs, how to check and evidence, plus a PR description template and a way to use AI as a first reviewer without trusting it blindly.
Field notes from one long working session with an AI agent on this very blog, measured from git history and the chat log: 12 commits, 33 messages, and the bugs only a human eye caught.
AI writes fluently but does not check facts. This article explains with everyday examples why an answer that sounds right can still be wrong, tells real cases from working with AI, and shows how to check before trusting.
Six eras of software development, from doorstop manuals and Stack Overflow to AI agents: how developers worked, where the bottleneck sat, and which skills to prepare for 2027–2030+.
Nothing matches yet. Try another keyword.