AI Tooling History - and why missing out can be rational

TL;DR

1. Skipping is fine. Products now bake planning, terminal use, and longer-running agents into the UI; open formats like AGENTS.md reduce per-tool config sprawl
2. A minimal setup is enough: repo AGENTS.md, a few skills, MCP only where built-in tools stop
3. Don’t fall for “bashword talk” - use the timeline and sources at the end of this article to shine with actual knowledge

I build websites and backends for a living. I like tooling, but I am not paid to live inside release notes. When AI coding assistants started to be come a thing, I tried them out. But: the honeymoon phase never happened at my end, maybe because I am a rather critical person when it comes to my work. In consequence, I deliberately sat out a lot of the early “power user” phase.

That was not laziness but rather a bet that the ecosystem would compress. So far, that bet has held. The interesting bit is what I use in my day job as Web Developer and keeping an overview in a rapidly changing ecosystem.

Why “missing out” can be rational

Every few months, social feeds declare a new baseline skill: agentic loops, MCP everything, repo-wide refactors from a single prompt, and so on.

As a web developer, the useful habits are still the same:

• Change one thing at a time and read the diff before you commit
• Run tests and your linter: in the end your agent is just an LLM putting out the most probable set of characters as a reply to your inquiry. Guard rails are what makes AI tooling useful when it comes to web development.
• Precise documentation is valuable. It always has been for the human reader but now agentic tools also benefit from it.

What changes every few months is the tooling around that: new models, agent modes, extra config files/config file location.

What I use today

Based on my tech stack, I have specific instructions regarding AGENTS.md files and also extended documentation like an ARCHITECTURE.md is project specific. The following paragraphs cover as generalized as possible insights with the scope of web development.

Built-in tools before plugins. Most coding agents today already expose the same primitives you would use yourself: search the tree (grep / ripgrep), read and edit files, run shell commands, sometimes fetch a URL. I default to that toolbox and only add a skill or use MCP when something is out of reach.

A simple AGENTS.md file. One file at the repository root for stack, test commands, and review habits; Global or user-level hints are fine for personal taste, but the contract with the codebase lives in the repository. If complex. you might want to add other markdown documentation

Skills for reappearing tasks. They are not an end in themselves When a class of work keeps needing the same background I use a skill (portable instructions the agent can load on demand). An example: I use an “issue-creator” skill in my day job to write GitHub items. I do not use a skill to write agent files because that is a one time job per repository and the skill will not be needed ever again.

DevTools MCP when the page is the source of truth. For web work, I occasionally attach Chrome DevTools MCP so the agent can inspect console, network, and DOM the way I would in DevTools; not because MCP should be everywhere, but because “fix the layout” without live page context is guesswork.

Modern Web Guidance skill for accesibillity. Combine it with the devtools MCP for a strong agentic frontend stack.

Plan for large work; agent mode for small diffs. If the model drifts, I revert and replan rather than arguing through a bad run.

That is the whole playbook for shipping. If you need the other half of the story—which capability landed when, in GitHub, GitLab, JetBrains, VS Code, Cursor, and the wider ecosystem, continue reading.

Timeline: capabilities and where they landed

Each section is one capability. Under Rollouts, the date is from the linked source (announcement or general availability), not when I first used it.

Inline code completion

Web-based chat

In-IDE chat

AI-native code editor

Multi-file edits

Agent mode

Plan mode

Model Context Protocol (MCP)

AGENTS.md

Closing thought

The best time to “miss” AI tooling hype is whenever the abstractions are still moving. Web development already has enough churn: frameworks, hosting, accessibility rules, and client expectations. Letting vendors fold agent planning, multi-file edits, and repo instructions into products and standards is not falling behind—it is waiting for the interface to settle.

You are reading this article instead of a six-hour YouTube retrospective because the goal is the same as a good migration or a good PR: enough context to act, none of the ceremony. Keep the setup small, use the timeline when a name needs a date, and spend the saved hours on the thing users see: the site.