1. I /init my existing codebase
Whenever I pick up a pre-existing codebase and want AI to be useful in it, the first thing I do is set up project-specific guidelines, rules, and skills, which I continue to refine over time. Used to take me a while to do manually. Now I just run /init.
Most popular CLI agents ship this command. It reads the current architecture and conventions and generates a CLAUDE.md or AGENTS.md that tells the agent what it's working with. It's a rough first cut, but it saves the setup time and you refine it as you go.
Personally, I have two global skills I use to init my project instead of the default. Whenever I work in a project with a team that isn't particularly AI-enthusiastic, I use /init-hush. It creates the .agents directory, adds it to .gitignore, and does the same for CLAUDE.md. Most of the time times, I run my regular /init skill, which I've extended to pick up file naming conventions, code structure, indexed abstractions, and components, then i commit the .agents directory so my co-devs can use and extend them.
2. I switched my code editor from Cursor to Zed!
I initially started AI-driven development with Cursor before all the Claude Code hype. It was beautiful. The transition from VS Code was smooth, Cursor felt like a natural upgrade, not a new tool to learn.
Over a long period of time, I added some extensions, tweaked a few things. Then it got slow. Really slow. And at some point I couldn't open three tabs simultaneously without pulling my small beard out. I heard about Zed from one of Ayo Adeoti's weekly meetups and made the switch a few weeks later. Its extension ecosystem is nowhere near as wide as VS Code's, however the speed difference is immediately obvious.
The major reason it made this list though is that it natively supports AI agents like Codex and Claude Code with no extension gymnastics, and how I can easily add and configure other providers for different things like Gemini for tab completions and commit messages. It's the cleanest agent-native setup I've tried, although I stil prefer to use the terminal in its agents sidebar specifically for Claude code, reason being; Anthropic realeases new features and commands at crazy speeds, and zeds acp interface takes some time to support them.
3. I create and research skills
If you don't already use skills actively in your workflow in big 2026, you're leaving a lot of productivity on the table. A skill is really just a markdown file that tells the agent how to behave in a specific context...That's it! The real unlock however, is that they aren't something you’d need to write alone in a vacuum. There's a whole marketplace of them now, other people's context on how to do a specific thing efficiently. packaged up and ready to drop into your agent.
The moment I notice I'm repeating a set of actions more than three times, I tell the agent to turn it into a skill, right in the same session.
One thing worth noting is the progressive disclosure model; how a skill is only loaded when the agent determines that it is needed based on the prompt and is not dumping everything into every context window.
I use the @skills CLI to manage and install skills from almost any GitHub repository, regardless of which agent I'm using:
npm install -g @skillsExamples:
npx skills find humanizer
npx skills add blader/humanizer --skill humanizer
npx skills add remotion-dev/skills --skill "*" --global
npx skills updatefind searches interactively across repos, add installs from a specific repo (--skill picks one by name, or * for all of them), --global installs at the user level instead of scoping to the current repo, and update refreshes everything you've already got installed. There's also --agent if you want to target a specific agent like Claude Code or Codex, and --copy if you'd rather have the files copied in instead of symlinked.
There are skills that teach the agent how to use the Google Workspace CLI effectively, and others that critique your UI's taste before you ship it. I tried the remotion best practices skill, among others, to generate a promotional video for Mobius-mcp without knowing a thing about remotion.
The result was complete trash by any standard, but I'm sure you'll have more luck than me with it.
I'll compile a list of skills I've discovered in another post.
4. I prefer CLI agents to IDEs like Cursor
Cursor IDE is fine. It helped me a lot early on. But once I started using Claude Code and Codex properly, trying to use an AI IDE solely again felt like going back to sticky notes.
The difference is where the agent lives. The AI enabled IDE ties the agent to that one editor. A CLI agent doesn't care where I am, it works the same in my local terminal or dev environment, in CI, in a random script on a server somewhere, they're more extensible. I can wire in whatever tooling and extensions the job needs instead of waiting on the IDE's plugin story to catch up, and can switch editors/IDEs without loosing my workflows, i.e global skills, connectors, etc.
Reading this again: don't get me wrong, I'm not saying you should drop Cursor if it's working for you, maybe you use it better than me, maybe the sticky notes thing was a slight exaggeration; however, if you haven't tried running an agent from the terminal alongside your IDE, or exposed to these usecases the comparison will surprise you.
Also, there's Cursor CLI 😉, haven’t tried it yet but it looks promising.
5. I check out a lot of MCPs and connectors
Half the friction in my workflow used to come from context switching. Agent writes some code, I need to check a Notion doc, I open a browser tab, copy, paste, repeat. MCPs kill that friction. Set them up once and the agent can pull context directly from the tools and services you already use.
It makes code sessions much faster and productive, Figma MCP enables me to procrastinate more comfortably, I don’t care if that’s a good thing or not, but you get the gist.
It takes maybe minutes to set up, and it keeps paying off long after. Notion, Linear, GitHub, Slack, Supabase, PostgresSQL, Sentry, PostHog, etc. whatever you use there’s probably an MCP for it and you don’t even know.
6. I keep a docs folder
I have a /docs folder in every project now, not for external documentation but for me... and the agent ofc.
Architecture decisions, Roadmaps, weird gotchas, notes on why a specific library was chosen, things that are not obvious from the code. The agent reads it and the quality of its suggestions goes up immediately. Less time re-explaining context. Fewer suggestions that miss the point.
It also makes onboarding new people (or a fresh agent session) dramatically faster. The docs folder is the working memory of the project.
7. I Run multiple sessions simultaneously
This one took me an embarrassingly long time to start doing. even thought its very popular already. Basically you can have multiple agent sessions running in parallel, no need to wait for one to finish before continuing your work.
I usually have three or four going: one on the main feature, one exploring a spike, one doing research or writing tests, one on another unrelated feature. They're independent and I context-switch between them the same way you would between browser tabs.
8. Use logs!!!
When your agent is going around in circles on a bug, and you're just too lazy to debug the issue yourself, the fastest way out is sometimes to let it make detailed logs and then give it access to read the logs and investigate the behaviour at runtime. What would be a twenty-message debug spiral often resolves in three: write the logs, reproduce the issue, read the output.
So I built an MCP server to expedite it. It's called mobius-mcp, and what it does is give your agent live access to your web app's runtime: console logs, errors, network requests, navigation events, all of it, without you touching the clipboard. A browser extension (or an npm client if you'd rather wire it into the app directly) streams events over a WebSocket to a local MCP server, and the agent reads them straight through MCP tools like get_recent_logs, get_recent_errors, and get_network_requests.
I started working on it this July, the project is opensource and I'm currently accepting contributions. you can install it like this:
claude mcp add mobius-mcp -- npx -y mobius-mcpOr drop this into your MCP client's config directly, works the same for Claude Code, Codex CLI, or Gemini CLI:
{
"mcpServers": {
"mobius-mcp": {
"command": "npx",
"args": ["-y", "mobius-mcp"]
}
}
}Enable capture on the tab you're debugging, and the agent stops asking you to paste console output and starts just reading it. It's the same "give the agent logs" instinct from above, minus the part where you need top tell the agent to check logs, or be the copy-paste bridge between the browser and the chat window.
That's the list. Half of it is tooling, half of it is just discipline I picked up after so many wasted hours. I'll keep experimenting, most of it still won't stick, but this is what's survived so far.
