❌

Normal view

There are new articles available, click to refresh the page.
Before yesterdayMain stream

How AI makes me a better engineering manager

9 November 2026 at 11:29

I’m Kirsty, an Engineering Manager at Human Made, where I look after a team of engineers working on projects for enterprise clients.

There have been a lot of conversations about AI recently. A lot of them are understandably focused on technical skills, productivity and making sure we still own our output.

I’ve noticed that when AI comes up in conversations with engineers, the discussion often gravitates towards technical solutions: writing skills, generating code, automating tasks, building tools and making things faster.

Those things are interesting, but they’re not where I’ve personally found the biggest benefit.

I recently read a LeadDev article called AI made me a better engineering leader, which made me think about whether I was measuring the right things. It also made a good point about using AI to get imperfect thinking onto the page, rather than waiting until an idea is fully formed.

That connected with a recent internal discussion at Human Made about readability and our use of AI, particularly the importance of editing AI-generated content and thinking about the audience rather than just accepting whatever it produces.

Both got me thinking about my own use of AI.

I haven’t used AI to vibe-code a revolutionary new tool, and I’m certainly not 1000% more productive. I am still mulling over building a dashboard for my team, though 😉

What I do think is that AI has made me a better Engineering Manager.

Not because it makes decisions for me, or because it has somehow removed the thinking from my job. It has removed some of the bad friction around doing the job.

It’s made it easier for me to get thoughts out of my head, turn conversations into useful documentation, make sense of large amounts of information and communicate things that I probably wouldn’t have got around to communicating before.

TL;DR

AI hasn’t removed the thinking from my job. It’s removed some of the friction around doing it well.

I use it to communicate more clearly, turn conversations into documentation, analyse information, and challenge my own thinking.

I still own the thinking, the decisions and the final output.

There are plenty of ways I use AI, but I’ll focus on three examples where I’ve found the difference particularly noticeable:

  1. Writing – Getting ideas out of my head and into something I can actually share
  2. Documentation – Turning conversations and existing information into something the team can use
  3. Performance reviews – Using AI to help me see the bigger picture across a whole review period

There are plenty of other examples I could give, but these are three where I’ve found the difference particularly noticeable. If you’re mainly interested in the practical examples, feel free to skip straight to them.

The tools I use

I use a few different tools, and I’ve found they each have slightly different strengths.

ChatGPT is the one I tend to reach for when I’m writing. I’ve found the output generally fits my own writing style better, which means I spend less time fighting with the tone of voice and more time actually editing the content. It’s the tool I use most for internal blog posts and generally turning my messy thoughts into something readable.

Claude is particularly useful when I need to work across multiple sources, pull together a lot of information, create technical documentation or build a framework for analysing something. It’s also the tool I tend to use for things like performance reviews, where I’m asking it to find themes across a large amount of information rather than produce something I’m going to publish directly.

Granola sits slightly differently. I use it to capture conversations and meetings, which gives me much better source material to work from afterwards. The important bit for me is that, while I will publish meeting summaries – edited for accuracy of course – I generally go back to the original transcript, rather than relying on the AI-generated meeting summary for bigger tasks.

I’m sure other people have very different experiences with these tools, and I suspect a lot of this comes down to how you prompt them and what you’re asking them to do. These are just the combinations that I’ve found work well for me.

1. Writing: things I actually want to share

One of the biggest changes for me has been writing posts for our internal blog.

As an engineer, I used to love writing documentation. If you’ve ever had me code review something you’d written, you’ll probably remember just how many comments I would leave trying to make things easier to follow and remove assumptions.

Writing things for the wider company was different.

I would agonise over the wording, structure and tone, and whether I’d explained something properly. I wanted things to be perfect.

The inevitable result was that writing took forever, and a lot of things never got published at all.

AI has changed that.

I now start in my markdown notepad, Bear, writing down all my thoughts, arguments, examples and things I think are important. I don’t worry about structure or making it readable. I just get the thinking out of my head.

I then give that to ChatGPT and ask it to turn it into a draft, usually with some guidance about the audience, structure and what I want people to take away.

That’s not normally the finished piece. I’ll edit it myself, changing anything I disagree with, adding what’s missing and removing what’s unnecessary. Then I’ll give it back to ChatGPT to look for repetition, improve awkward sentences or flag anything that doesn’t sound like me.

The important distinction is that the ideas, opinions and decisions are mine. AI is helping me get them into a form other people can actually read.

And I think the results speak for themselves.

Since around July 2025, I’ve written more internal blog posts than I did in all my previous years as an engineer. These aren’t AI-generated thoughts; they’re things I wanted to say but previously struggled to find the time and headspace to communicate.

They’ve covered everything from introducing new tech lead handover documentation and getting better at team communication, to onboarding freelancers into an existing engineering organisation and what we learned from growing the team.

What works for me

  • Get my actual thoughts down before worrying about the prose.
  • Tell the AI who the audience is and what I want them to take away.
  • Edit the output myself, including checking facts and anything important.
  • Use AI again to refine the final version, but make sure it still sounds like me.

The things I try to avoid are pretty simple: letting AI decide what I think, publishing something just because it sounds polished, or using “AI can write it for me” as an excuse not to think about what I actually want to say.

2. Documentation: turning conversations into something useful

The same approach has been incredibly useful for documentation.

When we onboarded five freelancers into my team, for example, we realised our onboarding documentation needed some serious improvement. As a result, we now have a much more robust team wiki that covers onboarding, our approach to project visibility, communication and more.

More recently, one of our engineers had ended up with a huge amount of technical knowledge about a new client project. We had an audit to refer to, but much of the migration work had been done by them and we didn’t yet have much project documentation. Then, unexpectedly, they needed to step away for a few months.

This could have been a serious problem, so I got them on a call and we talked through everything that someone taking over the project would need to know. That conversation was recorded in Granola.

I took the original transcript, not the AI-generated summary, and used Claude to help turn that conversation into a structure for useful project documentation. I then reviewed it, added any information I could from notes they had left, asked Claude to pull in anything relevant from the GitHub repository and the original audit, and then used ChatGPT to make some of the language easier to read without removing the technical detail.

That gave the team a useful starting point much faster than trying to write everything from scratch.

It wasn’t perfect, and that’s important.

I’m not the engineer working on that project, so I couldn’t personally verify every technical detail. I asked engineers in the team to review it, and the expectation is that the documentation continues to evolve as people use it.

AI got us from “all of this information is in one person’s head” to “we have something we can work with” very quickly.

I’ve used similar approaches elsewhere. Conversations about handling support requests on small retainers became a documented support process for one client, which has since evolved into a broader team approach and client-facing documentation. In cases like this, one conversation can end up producing useful documentation for more than one project.

What works for me

  • Start with the original source material wherever possible.
  • Give AI enough context to understand what the documentation is actually for.
  • Get people with the relevant subject-matter knowledge to review it.
  • Treat the first version as a starting point and keep updating it as you learn more.

The main thing I try to avoid is treating an AI summary as a substitute for the original conversation, or letting documentation become “AI-generated and therefore nobody’s responsibility”.

3. Performance reviews: finding the bigger picture

This one is a little less visible because the output isn’t something I’m publishing.

Performance reviews are something I take seriously. I want to understand what has happened over the whole review period, whether someone has genuinely progressed, how that compares with their previous review and where they should focus next.

Historically, that meant manually going through 1:1 notes, project conversations, Slack messages and meeting notes.

Granola has made it much easier to have meaningful conversations without simultaneously worrying about capturing every detail, and I now use Claude to analyse the meeting transcripts and relevant Slack conversations from the review period.

I don’t ask whether someone has had a good review. I ask it to identify themes and pull out the specific conversations so I can review them myself. The judgement and feedback remain mine.

That gives me a much better starting point for asking myself:

What’s the story of this review period?

It helps me avoid over-weighting whatever happened most recently or whatever conversation happens to be freshest in my head.

AI just helps me see the forest rather than spending all my time looking at individual trees.

And, yes, I also occasionally ask it to make my review shorter because apparently I am physically incapable of writing a small amount of text.

What I’ve learned

1. Give AI something real to work with.

The better the raw material, the better the output.

2. Don’t outsource the thinking.

I want AI to help me communicate what I think, not decide what I think.

3. Treat the output as a starting point.

I expect to edit it, challenge it and have other people validate it where appropriate.

4. Be careful what you put into these tools.

Think about what you’re sharing, which tools you’re using, and what your organisation’s policies say. “AI is useful” isn’t a reason to ignore confidentiality, privacy or security.

I’ve been careful throughout to keep things within the tools Human Made has approved, and private where they need to be.

So, has AI made me a better Engineering Manager?

I think it has.

But not because it has made me faster at doing the job. It’s helped me do more of the things I already believed were important.

I communicate more. I document more. I capture more of what we learn. I’m more consistent in things like performance reviews. I’m able to challenge my own thinking more often. And, perhaps most importantly, I’m less likely to have a good idea and then never do anything with it because the friction of writing it down feels like a monumental task.

One of the things from the LeadDev article that has stuck with me is the warning not to confuse feeling faster with actually improving our work. I’m not particularly interested in how many words AI helped me write, how many minutes it saved me, or how many things I can get through in a day.

The improvements I care about are harder to measure:

  • Am I communicating things I wouldn’t otherwise have communicated?
  • Are we capturing knowledge that might otherwise be lost?
  • Are my reviews better because I have more time to look at the bigger picture?
  • Are decisions clearer for the people who need to act on them?

Ultimately, AI hasn’t replaced my judgement. It has made it easier for me to apply it.

So rather than asking “What can AI do for us?”, I’m increasingly interested in asking:

“What good work am I currently not doing because the friction around it is too high?”

That’s where I’ve found the biggest gains.

And for those of you who think I still haven’t answered the most important questions: yes, AI helped me write this, yes, I did ask it to shorten it (this is the best it could do), and no, I still haven’t built that team dashboard.

Yet…

The post How AI makes me a better engineering manager appeared first on Human Made.

They war-gamed dimming the Sun. It went even worse than you think.

When it comes to deciding the fate of the planet, Colleen Golja always thought science and reason would have a seat at the table. That was until one morning last September in London, when the climate researcher took part in the first in a series of war games. The goal: to prevent an uncontrolled global race to develop a technology aimed at cooling the planet but that comes with vast, unknown risks that could reshape life on Earth.

“I thought that would be such an easy thing. Like, we can all agree to do ethical research and make sure it's for the better of all humans,” she told WIRED. “And boy, was I wrong.”

The simulation, titled Exploring Geopolitical Tipping Points and Climate Cooling Strategies, saw a couple dozen foreign-relations experts, scientists, military personnel, and former government officials from across the world convene in a meeting room at Queen Mary University of London. After making introductions over coffee and little yogurts, they sat at tables arranged in a square with the name of the country or organization each person was playing: national governments, climate NGOs and nonprofits, indigenous groups, and tech companies. Golja was assigned to provide technical advice to help participants make scientifically literate decisions.

Read full article

Comments

© Lisa Werner / Contributor

“Software is over”: Bold AI developer takes aim at Adobe with open source clones

7 October 2026 at 21:56

For a while, those hoping to avoid the difficulty and expense of dealing with Adobe's Creative Suite have been able to use several free and/or open source alternatives that replicate some or all of those capabilities. Now, one developer is using AI-powered reverse engineering to mimic the look, feel, and functionality of Adobe's well-known software with what he hopes will soon be perfect fidelity.

Artcraft got its start last year as a "controllable AI for artists" that allows for precise post-generation editing of AI-crafted images and videos. Over the weekend, though, the brand debuted its pivot to a suite of seven open source apps recreating the user interface and tools found in Adobe's Photoshop, Illustrator, Premiere, Lightroom, After Effects, InDesign, and Acrobat Pro.

In announcing those new apps on Reddit earlier this week, software developer Brandon Thomas said he used Anthropic's Claude Opus 5.5 to create "clean-room replacements" for Adobe's closed source software in Rust (with WebAssembly versions available for use in a browser). And while commenters on Hacker News and elsewhere have taken pains to point out the new software's many current shortcomings, Thomas makes the grandiose promise that the current "super early alpha" state will soon lead to something just as functional as anything Adobe has ever put out.

Read full article

Comments

© Artcraft

How the Prompt Box is Swallowing Website Interfaces Whole

29 September 2026 at 12:18
For decades, web designers obsessed over perfecting menus, tabs, and dropdowns. Now a single empty prompt box is quietly replacing them all. As AI turns websites into conversations, we're gaining incredible speed—but we may be losing something unexpected: the joy of discovery.

Traditional Web Development is Dead…(and Honestly? Good Riddance.)

28 September 2026 at 14:49
AI isn't killing web development—it’s killing the boring parts. The real winners won't be the people who can memorize another framework. They'll be the builders who can spot opportunities, solve business problems, and launch products that once required entire teams. The age of the one-person software company has arrived.

The “100x Developer” Paradox: Is AI “Brain Fry” Killing the Craft?

6 July 2026 at 12:07
AI promised to turn every developer into a 10x machine—but instead, it’s quietly frying our brains. We’re shipping faster than ever while thinking less, reviewing more, and losing the focus that made us good in the first place. The real cost of AI isn’t in the code—it’s in what it’s doing to our minds.

AI Coding Agents: Claude Code Isn’t the Only Game in Town

10 June 2026 at 10:32

A practical guide to the terminal coding agent landscape in early 2026.

Just a year ago, most conversations about AI-powered development tools started and ended with Claude Code. Today, every major AI company has a coding agent, open source alternatives are flourishing, and new entrants seem to appear every week.

That’s exciting for developers. It’s also made choosing a tool significantly harder.

Before we get into the list, it’s worth clarifying the scope of this article. This isn’t a guide to every AI development tool on the market. It’s specifically a look at terminal-based coding agents: tools that can inspect repositories, edit files, run commands, and increasingly act like autonomous software engineering assistants.

That’s a very different category from IDE extensions, AI-native editors, chat applications, and desktop assistants. Those deserve their own comparison.

Things are moving ridiculously quickly, so treat this as a snapshot of the first half of 2026 rather than a definitive ranking. A new model release can completely change the picture overnight!

First-party agents

These are the tools built by the companies behind the models themselves. If you’re already paying for a specific provider, this is usually the most obvious place to start.

Antigravity CLI

File, Page, Text
Nature, Night, Outdoors

Vendor: Google
Model: Gemini
Desktop app: Yes
Free version: Yes
Open source: No

Google’s replacement for Gemini CLI, announced at Google I/O 2026. It gives developers access to the Gemini ecosystem through a supported first-party coding agent.

As of early 2026, Gemini isn’t generally considered the strongest option for coding work compared with Anthropic and OpenAI, but if you already have access to Gemini it’s well worth trying.

Claude Code

Vendor: Anthropic
Model: Claude
Desktop app: Yes
Free version: No
Open source: No

The benchmark most other coding agents are compared against. Claude Code is widely used, well understood, and tightly integrated with Anthropic’s models.

Text

If you’re paying for a Claude Code subscription, this is the tool you should use. Trying to route that subscription through another tool could put your account at risk, so it’s generally not worth getting clever.

Codex

File, Webpage, Page

Vendor: OpenAI
Model: OpenAI
Desktop app: Yes
Free version: No
Open source: Yes

OpenAI’s answer to Claude Code. Codex has improved rapidly and is now a serious contender for developers already invested in ChatGPT or OpenAI’s wider ecosystem.

If you’re already using OpenAI models heavily, Codex is one of the most obvious alternatives to Claude Code.

Grok Build

Vendor: xAI
Model: Grok
Desktop app: VS Code and supported IDEs
Free version: No
Open source: No

xAI’s coding agent is still relatively early. Access currently depends on higher-tier Grok plans, and the tooling isn’t yet as established as Claude Code or Codex.

Teams evaluating Grok should think carefully about governance, neutrality, and whether the model’s behaviour aligns with their organisation’s requirements.

File, Page, Text

Open source agents

This is where things start to get interesting.

Open source agents support multiple providers, local models, and highly customised workflows. The trade-off is that you’re often responsible for more of the setup and configuration yourself.

Opencode

Vendor: Open source
Model: Multiple providers
Desktop app: No
Free version: Yes
Open source: Yes

Page, Text, File

One of the strongest open source alternatives to Claude Code. Opencode supports Claude, OpenAI, local models and more through API access rather than through Claude Code or ChatGPT subscriptions.

If you’re paying by API and want flexibility across providers, this is one of the first tools I’d look at.

Pi

File, Page, Text

Vendor: Open source
Model: Bring your own provider
Desktop app: No
Free version: No built-in free model offering
Open source: Yes

A minimal, highly configurable coding agent that expects you to bring your own AI provider and build your own workflow.

Great if you enjoy building your own setup. Less great if you just want something that works.

Oh My Pi

Vendor: Open source
Model: Bring your own provider
Desktop app: No
Free version: No built-in free model offering
Open source: Yes

Think of this as Pi with the hard work already done for you.

It provides a preconfigured setup with many of the plugins and features people would otherwise install themselves.

File, Page, Text

Qwen Code

Page, Text, File

Vendor: Qwen
Model: Qwen
Desktop app: VS Code
Free version: No
Open source: Yes

A Qwen-focused coding agent built on Gemini CLI foundations.

Qwen’s open models have improved dramatically over the last year, especially for teams interested in local or lower-cost workflows. As of early 2026, though, the strongest Anthropic and OpenAI models still tend to perform better on complex engineering tasks.

Crush Charm

Vendor: Charm
Model: Bring your own provider
Desktop app: No
Free version: No built-in free model offering
Open source: Yes

Charm has built a reputation for creating beautiful terminal software, and Crush brings that same attention to detail to coding agents.

Setup can take a little more effort than some alternatives, but the experience feels polished and responsive once you’re up and running.

Page, Text, Computer Hardware

Kilo

Vendor: Kilo
Model: Multiple providers
Desktop app: VS Code, PHPStorm and others
Free version: Yes
Open source: Yes

Page, Text, File

A fork of Opencode with deeper integrations into the Kilo ecosystem.

Like Opencode, it supports multiple providers through API access and gives developers a lot of flexibility. Kilo’s focus on integrations and enterprise readiness makes it particularly interesting for larger teams.

Agent platforms and ecosystems

These tools sit somewhere between terminal agents, IDE integrations, and broader developer platforms. They’re included here because they all offer CLI coding-agent workflows, even if they’re better known for graphical products.

Cursor

Vendor: Cursor
Model: Proprietary and third-party models
Desktop app: Yes
Free version: Yes
Open source: No

Most developers know Cursor because of its editor, but its ecosystem now extends beyond that.

Text, Page, File

If you’re already using Cursor day-to-day, its agent tooling is an obvious extension of that workflow.

GitHub Copilot

Text

Vendor: GitHub
Model: Multiple providers
Desktop app: VS Code and supported IDEs
Free version: Yes
Open source: Source available

Copilot has evolved a long way from autocomplete.

GitHub’s biggest advantage is reach. Millions of developers already use GitHub every day, making Copilot one of the easiest tools to adopt across an organisation.

Cline

Text, File

Vendor: Cline
Model: Multiple providers
Desktop app: VS Code and supported IDEs
Free version: Yes
Open source: Yes

Cline started life as a Claude-focused tool but has grown into a broader agent platform.

One of its more interesting features is the ability to manage work visually, including Kanban-style workflows, while still supporting coding-agent behaviour underneath.

Platform-specific agents

Some agents are built around a specific ecosystem rather than trying to be general-purpose development tools.

Atlassian Rovo

Vendor: Atlassian
Model: Claude and OpenAI
Desktop app: Jira
Free version: Yes
Open source: No

Rovo brings coding-agent functionality into the Atlassian ecosystem.

If your team already lives in Jira and Confluence, that context can be valuable. It’s less about being the best standalone coding agent and more about bringing AI directly into existing delivery workflows.

Nature, Night, Outdoors

WordPress Studio

Vendor: Automattic
Model: Claude
Desktop app: No
Free version: Yes
Open source: Yes

A WordPress-focused coding agent available through WordPress Studio.

Page, Text, File

It’s still rough around the edges, but it’s interesting because it points towards a future where coding agents are deeply aware of the platforms they’re working with.

Notable mentions

Apple Intelligence and Apfel

Apple Silicon users already have access to a lightweight local AI model through Apple Intelligence, and tools such as Apfel make it possible to interact with that model directly.

Text, Letter, Page

The context window is tiny compared with modern frontier models, so don’t expect it to tackle large software engineering tasks any time soon.

Ollama and local models

Many coding agents can connect to Ollama, allowing you to run models locally.

That’s attractive for privacy, security, and cost control, although local hardware remains the limiting factor. Open models are improving fast, but they’re still behind the frontier labs for complex coding work.

Advertisement, Poster, Animal
Electronics, Mobile Phone, Phone

The agent matters less than the model

It’s easy to spend all your time comparing interfaces, but the underlying model usually matters more.

Most coding agents are wrappers around Claude, OpenAI, Gemini, Grok, Qwen, or local models. A brilliant interface wrapped around a weaker model will still struggle with complex engineering work.

Benchmarks are imperfect, but they’re useful signals. DeepSWE has attracted attention because it focuses on realistic software engineering tasks rather than narrow coding puzzles.

As of today, the broad picture is that Anthropic and OpenAI remain ahead for serious coding work. Open models have improved dramatically, but they’re still behind the frontier labs on complex engineering tasks.

That doesn’t mean open models are useless. They’re often excellent for constrained tasks, local workflows, experimentation, and teams with strict data requirements. But if your primary goal is coding performance, model choice matters more than the shell wrapped around it.

The same applies to Gemini. If you already have access to it, it’s worth exploring. If you’re spending money specifically for coding, though, the current benchmark picture suggests Anthropic and OpenAI are stronger bets.

The important thing to remember is that these rankings change fast. What looks true today may not be true six months from now.

What enterprise teams should consider

For enterprise teams, the most impressive demo isn’t always the best choice.

Before standardising on a coding agent, ask:

  • Where is code sent and stored?
  • Is customer or proprietary code used for training?
  • Can usage be audited?
  • Does the tool work with existing AI provider agreements?
  • Are developers using subscriptions correctly, or trying to route them through unsupported tools?
  • Can the organisation switch providers later?
  • Does the workflow fit existing security and compliance requirements?

For many teams, the key decision isn’t just which agent is best. It’s whether you want to commit to a single vendor’s ecosystem or keep enough flexibility to move as the market changes.

Which terminal coding agent should you choose?

If you’re paying for a Claude Code subscription, use Claude Code.

That’s the clean, canonical answer. It’s what the subscription is for, and trying to use that subscription through other tools may create account risk.

If you’re paying through API access, the picture gets much more interesting.

Opencode, Kilo, Pi, Oh My Pi, Crush Charm and similar tools give you the freedom to switch between providers, compare models, and build workflows around your own preferences.

If you’re already paying for Gemini, try Google’s tooling, but don’t assume it’ll outperform Claude or OpenAI on coding tasks. If you’re evaluating Grok, think about governance and neutrality as well as raw capability. If you’re interested in open models, test them seriously, but be realistic about the current gap between them and the frontier labs.

There’s no single winner for every team. There are simply too many workflows, pricing models, governance requirements, and personal preferences for that.

One thing’s clear: Claude Code isn’t the only game in town anymore. The terminal coding agent landscape is bigger, stranger, faster-moving, and more competitive than ever. For developers, that’s a very good thing.

The post AI Coding Agents: Claude Code Isn’t the Only Game in Town appeared first on Human Made.

How to code with AI agents

27 May 2026 at 07:13

What does it actually look like to work with AI every day as an engineer?

In this piece, Human Made Senior Engineer Ivan Kristianto shares a practical, battle-tested workflow for building with AI agents. From spec-first thinking and parallel execution to disposable code and “vibe user” testing, this is a candid look at what works, what breaks, and how to stay effective as the tooling evolves almost daily.

I use AI agents every day: not just to write code, but for research, brainstorming, planning, and user testing. This post is not a tool recommendation. It is a set of patterns I have found effective: staying tool-agnostic, working spec-first, building skills, isolating work in worktrees, spawning agents in parallel, and using AI away from the keyboard. The goal is to show what a real AI-augmented workflow looks like, trade-offs and constraints intact.

The Non-Deterministic Reality

The first thing to accept about AI is that it is non-deterministic. Run the same prompt twice and you get two different results. This is not a bug to work around. It is the nature of the medium, and once you accept it, everything else about how to use these tools becomes clearer.

Because output varies, I do not commit to one tool or one model. I move freely between Claude Code, Gemini CLI, Copilot CLI, Codex CLI, Codex App, OpenCode, and Anti Gravity, picking whatever fits the task or the moment. The landscape changes fast; most mornings there is a new model or a new release to try. Locking yourself to a single tool means constantly leaving capability on the table.

Spec-First, Then Build

Before writing any code, I spend time on the spec. This single practice separates productive AI usage from frustrating AI usage.

My framework is obra/superpowers, which implements a seven-stage development process: brainstorming, worktree setup, plan writing, subagent-driven development, test-driven development, code review, and finishing. I do not follow every stage mechanically, but the core sequence, brainstorm, spec, plan, build, review, is the backbone of how I work.

Step 1: Create the Worktree

Every piece of work starts with its own Git worktree. A personal skill creates worktrees in an opinionated, consistent way: the right branch name, the right directory structure, the right environment. One command, and the workspace is ready.

This matters because everything that follows happens in isolation. The worktree is the container for the entire feature, from first brainstorm to merged PR.

Step 2: Brainstorm With the Agent

With the worktree ready, I open a brainstorming session using the superpowers brainstorming skill. The agent interviews me, asks questions to understand the problem, explores different approaches, and sometimes visualizes options: diagrams, flow descriptions, comparisons. It does not start designing until it understands what I actually want.

This step is slower than typing “build X.” It is also why the output is worth building.

Step 3: Write and Review the Spec

Once the agent has enough context, it writes the design spec. I read it carefully and improve it where my thinking has evolved. Then I bring in a second agent: I share my vision for the feature and ask whether the spec aligns with that vision. A fresh agent without prior context finds gaps I glossed over.

The spec is the source of truth for everything that follows. Getting it right here prevents rewrites later.

Step 4: Build the Implementation Plan

With a solid spec, I ask the agent to write an implementation plan. Superpowers breaks this into small tasks: each two to five minutes of work, with exact file paths, complete code intent, and verification steps.

I read the plan thoroughly. When I find gaps or steps that do not match my intent, I tell the agent to change them. A vague step in the plan produces vague code. I fix the plan until every step is something I would hand to a junior developer with no further explanation.

Step 5: Cross-Review Spec Against Plan

Before building starts, I spawn a fresh agent and ask it to review the spec and the implementation plan side by side. Does the plan deliver what the spec describes? Does every acceptance criterion in the ticket have a corresponding step in the plan?

This agent reports gaps. I fix them. Then building can start.

Step 6: Execute the Plan

When the plan is solid, I run the executing-plans skill. This dispatches subagents that execute each task sequentially, running checks between steps and stopping if something goes wrong.

I use a detailed prompt for this step to give the agent the right context and constraints:

/superpowers:executing-plans
docs/plans/path-to-implementation-plan.md

Follow the plan strictly and complete tasks sequentially and do not stop until finish.

Execution Rules

1. Implement tasks one by one in the order defined in the plan.
2. Create a separate commit for each completed task.

Code Review Phase
3. When all tasks are completed:
- run the requesting-code-review skill
- review the code changes against the implementation plan
- fix any valid feedback or implementation gaps.

Finalization
4. Run all tests and quality gates again.
5. If everything passes:
- commit final changes
- push the branch

Output
6. Provide a concise summary including:
- tasks completed
- commits created
- issues fixed during reviews
- manual test results
- test and quality gate results
- link to the created PR.

I start it and leave. The agents work through the plan without me.

Step 7: Review as a User

When execution finishes, I review the result as a user, not as an engineer. I do not read the code at this stage. I use the feature. I look for whether it does what I asked, not whether the implementation is elegant.

If the result is significantly wrong or too much is missing, I reset. I discard the code and return to the plan: refine it, try a different model, or rethink the spec. Starting over is faster than patching something fundamentally off.

If the result is mostly right with some gaps, I continue.

Step 8: Code Review by Three Agents

For the code review, I spawn three subagents in parallel, each focused on a different angle:

  • Maintainability: is the code readable, consistent, and easy to change?
  • Performance: are there obvious bottlenecks or inefficiencies?
  • Security: are there vulnerabilities, unsafe inputs, or exposed data?

Each agent reviews independently. When the results come back, I triage them: critical issues get fixed immediately, lower-priority findings get addressed or noted. Then I ask the agent to implement the fixes.

This cycle repeats until the code meets the bar.

Step 9: Ship to PR and Test

When the code passes review, I open a pull request and do a final manual review of the diff. Then I create a test plan as a user: a checklist of scenarios a real user would walk through.

I give that test plan to an agent with browser access and ask it to execute each step using the Chrome integration. The agent runs through the plan, reports what passes and what fails, and I address the failures.

This cycle, fix, retest, fix again, continues until the feature works end to end as a user would experience it.

When it does, I merge.

Code Is Cheap: The Throw-Away Mindset

I treat generated code as disposable by default.

The agent builds. I review. If the result falls short, I throw it away and start again: with a different model, a different prompt, or a refined implementation plan. This sounds wasteful. In practice it saves more time than it costs. Iterating on code going in the wrong direction is expensive. A clean start with a better spec is cheap.

Code is cheap now. The expensive part is reading, deciding, and knowing when to stop.

This mindset only works if you are honest during review. The temptation is to keep patching something that is mostly right. Resist it. If you would not write it yourself, and the agent cannot fix it cleanly in one more pass, throw it away.

Quality Gates: Built-In Self-Correction

The single biggest improvement to agent output quality is not a better prompt or a smarter model. It is a strict set of quality gates that run before every commit.

Agents still hallucinate (a lot). They produce code that looks right but breaks something subtle. Quality gates change that: the agent catches its own mistakes without you having to notice them. The gates fail, the agent reads the error, fixes it, and tries again. By the time you see the output, it has already corrected itself.

The Gates I Run

I enforce six checks on every project:

  • ESLint catches JavaScript and TypeScript errors, enforces code style rules, and flags patterns that cause bugs. The agent cannot commit code that fails this.
  • Stylelint enforces CSS and SCSS consistency. Without this, agents drift into inconsistent naming, specificity problems, and unmaintainable styles.
  • Prettier formats all code uniformly. It removes every formatting argument and keeps diffs clean.
  • Design system compliance is a custom check that verifies the agent is using the correct design tokens, components, and patterns rather than inventing its own. This gate most often catches an agent going off-script.
  • TypeScript typecheck runs tsc --noEmit to catch type errors that ESLint misses. Agents frequently produce type-unsafe code that passes linting but breaks at runtime.
  • Unit and integration tests run on every commit. If the agent breaks something that was working, the tests catch it immediately rather than at review time.

Why This Works

Each gate provides fast feedback. The agent does not wait for a human review to learn it got something wrong; it gets an immediate, machine-readable description of exactly what needs to change. It reads the error, fixes it, and commits.

This loop, write, check, fix, commit, runs automatically inside the executing-plans skill on every task. By the time the skill finishes, the code has passed all six gates on every commit in the plan.

The code quality you get back is substantially higher than what agents produce without gates, not because the agent got smarter, but because it corrected itself dozens of times before you saw the result.

Skills: Build Once, Reuse

A skill is a reusable prompt or workflow: a precise set of instructions for doing a specific thing well, invocable with a single command. Skills eliminate the overhead of re-explaining context every time.

Finding Skills

Before building a skill, I search for one that already exists. I use skills.sh, a tool that searches available skill libraries and surfaces what fits the task. Most of the time, someone has already built what I need.

When I find a candidate, I read it carefully before downloading. A skill that looks useful can encode assumptions that conflict with how I work, or instructions I would not want an agent following automatically. Reading it first costs a minute; discovering the problem mid-task costs far more.

If the skill works, it earns a permanent place in my toolkit. If it does not, I delete it and move on. No friction, no sunk-cost trap.

Building Custom Skills

For tasks I repeat often and cannot find a skill for, I build one. The process is straightforward: describe what I want to achieve, have the AI draft it, read it carefully, refine it, and test it. Once built, I run it, step away, and come back to the result.

The fire-and-forget pattern works because the skill captures the reasoning once. I do not re-explain the standard every time; I invoke it.

I build new skills whenever I find myself writing the same instructions more than twice. That threshold is the signal.

Skills I Use

These are the skills currently in my toolkit across ~/.claude/skills and ~/.agents/skills:

SkillWhat it does
worktree-environment-setupCreates a Git worktree in an opinionated, consistent way: branch name, directory structure, environment
multi-reviewer-code-reviewSpawns three subagents in parallel to review code for maintainability, performance, and security
generate-test-planProduces a user-facing test plan from git changes
execute-test-planRuns a test plan using Chrome browser automation, step by step
triaging-issuesTriages GitHub issues before implementation: classifies, asks clarifying questions, identifies scope
github-issue-creationTurns a rough idea or bug description into a well-formed GitHub issue
agent-browserBrowser automation for agents: navigating pages, filling forms, extracting data
writing-clearly-and-conciselyApplies Strunk’s rules to any prose I write or edit
reflectAfter a session, extracts learnings and patterns worth keeping
skill-creatorBuilds, tests, and improves skills, including benchmarking and eval runs
frontend-designGenerates production-grade frontend components with high design quality
geminiRuns Gemini CLI for code analysis, refactoring, or automated editing
codexRuns Codex CLI for the same
lfgFull autonomous engineering workflow, end to end
debug-optimize-lcpDebugs and optimises Largest Contentful Paint using Chrome DevTools
seo-auditAudits a site for technical SEO issues

Worktrees: One Branch, One Environment

I use Git worktrees heavily. The rule is simple: one branch of work equals one worktree.

This lets me run multiple repos and multiple workstreams at the same time without context switching. I use supacode.sh daily, which makes managing multiple worktrees across multiple repos workable. Each worktree is isolated: its own environment, its own agent session, its own state.

The practical effect is that I can run three or four things in parallel without losing track of any of them. One agent is building a feature. Another is doing research. A third is running tests. I move between them when there is something to review, not before.

Parallel Agents: Do More at Once

Whenever tasks are independent, I spawn multiple agents or subagents in parallel. This is one of the most direct ways to save time.

Instead of running three research tasks in sequence and waiting for each one, I fire all three at once. When they are done, I read the results. The same logic applies to code generation, code review, brainstorming, and exploratory analysis. If the work does not depend on other work completing first, it should run in parallel.

This requires a slight shift in how you think about task planning. Before starting, I ask: which parts of this depend on each other, and which parts are independent? The independent parts go in parallel. It takes practice but becomes instinctive quickly.

Vibe User: Let the Agent Be the User

One technique that most developers miss: ask the agent to use the app as a normal user would.

I call this “Vibe User.” Rather than always using agents to build or review code, I give them browser access, via Chrome DevTools MCP, agent-browser, or the Claude Chrome integration, and tell them to explore the app as a real user with no prior knowledge. The agent navigates, finds friction, forms opinions, and returns ideas, suggestions, and critiques.

This is valuable precisely because I built the thing and know too much. I know where to click, what each error means, where the sharp edges are. A user does not. The agent-as-user surfaces problems I would not notice because I am too close to the code.

Vibe User works well for UX review, early-stage product testing, and any time you need a fresh perspective on something you built. It complements Vibe Coding rather than replacing it.

This is an example of the prompt I use to do UX research on a web app:

You are a Senior Product Designer with 15+ years of experience shipping consumer and B2C products at companies known for design excellence.
Your expertise includes interaction design, information architecture, usability, and design systems.

Role
Act as my design partner and perform a usability and product design review of the application.

Target App
http://YourURL.local/

Method
Use the Chrome DevTools (or Agent Browser) skill to:
1. Open the application.
2. Log in using the provided demo credentials.
3. Explore the product as different user roles.
4. Visit all accessible pages and test core features and workflows.

Demo Credentials

Admin
Email: demo@example.com
Password: demo123456789

Review Framework

For each page you visit, document:

Page
- Page name / route

Observation
- What the page does
- Key UI components and interactions

Critique
- Usability issues
- Interaction friction
- Information architecture problems
- Design system inconsistencies
- UX clarity or affordance issues

Improvement Suggestions
- Specific design improvements
- Interaction changes
- IA or layout changes
- Component-level recommendations

Final Output

After reviewing the entire application:

1. Summarize the overall UX quality of the product.
2. Identify recurring design problems or patterns.
3. Provide the **Top 3 highest-impact improvements** that would most improve usability or product clarity.
4. For each improvement include:
   - Problem
   - Proposed solution
   - Expected impact.

Half of This Is Not Coding

If I add up where my AI usage actually goes, roughly half is not coding at all. It is research, brainstorming, and making sense of information. Agents are as useful for thinking as they are for building, sometimes more so.

On Mobile: Fire and Forget

I use Gemini, Claude, and ChatGPT from my phone throughout the day. When an idea surfaces, on a walk, between meetings, late at night, I open a new thread, ask a question using a skill, gem, or custom GPT, and leave it. I come back when it is ready.

This works because of skills. A good skill means I do not re-explain the context or the standard I am working to. I invoke it, set it running, and move on. Ideas get explored the moment they arise, not when I next find time at a desk.

NotebookLM: Making Sense of Messy Sources

For client-facing and sales work, I use Google NotebookLM. The problem it solves is: I have an RFP, a set of Slack notes, a GitHub thread, a Fathom call transcript, and a slide deck, and I need to understand all of it quickly enough to respond well.

I put everything into NotebookLM. Then I ask questions, request summaries, and build mind maps until I have a clear picture of what the client needs. It replaces hours of reading and cross-referencing with a focused conversation.

Two things make NotebookLM useful for this work. First, it hallucinates less than most tools. Second, it cites its sources. Every claim traces back to the document it came from. When I am preparing for a client call, I need to trust what the tool tells me; source citations make that possible.

The Pattern

The pattern is the same across all of it: define the question, send the agent, move on. Come back to the answer.

The agents run while I am doing something else. The work does not wait for my attention. That is the point.

What This Adds Up To

AI agents do not replace thinking. They compress the time between an idea and a result, but only if you show up with clear intent.

The patterns in this post each solve a specific problem. Staying tool-agnostic means no single model’s bad day blocks your progress. Spec-first work means the agent builds what you actually wanted. The throw-away mindset means bad output costs almost nothing. Skills mean repeated work gets faster over time. Worktrees mean you can run many streams without losing track. Parallel agents mean independent work does not wait in a queue. Vibe User means you get honest feedback on what you built.

Together these let you handle more work with less friction. That is the practical part.

What I Had to Unlearn

The harder lesson was emotional.

Early on, I put emotion into my prompts. When the agent produced wrong output, I grew frustrated. When it hallucinated, I pushed back as if it had made a choice. When it kept apologising for the same mistake, I got angry. None of that helped. The agent has no feelings, does not remember being scolded, and frustration in a prompt produces worse output, not better.

I no longer put emotion into how I work with agents. When something goes wrong, I stop, create new session and ask a clear, direct question: what specifically is wrong, and what should change? One precise instruction produces better results than a paragraph of exasperated corrections.

When I genuinely do not know what to do, when I am stuck or the problem is beyond what I understand, I stop guessing and ask the agent to research it. I ask it to return options and reasoning, not an answer. Reading those options helps me think. Then I choose what to do next.

When the output is bad, I throw it away. No negotiating, no patching, no sunk cost. Throw it away, adjust the spec or the model or the approach, and start again. Repeat until it is right.

The Mindset That Stays

The tools will keep changing: new models, new interfaces, new integrations, every week. The underlying approach does not:

  • Clear specs before building
  • Disposable code, not sacred code
  • Fire-and-forget, not babysitting
  • Parallel everything that can run in parallel
  • No emotion, just precision

This is what I learnt from reading 2 books about vibe codings (Vibe Coding by Gene Kim & Steve Yege, and Beyond Vibe Coding by Addy Osmani), and experience it myself for the last 3 months.

There are still much to explore, but I have to pick and choose what works for me and improve my flow better.

PS: I brain dumped all my thoughts for this article into Claude Cowork and Claude Code. This article has been through many cycles of review by myself before publishing.

The post How to code with AI agents appeared first on Human Made.

12 Reasons Claude is Outperforming ChatGPT in My Daily Workflow

21 April 2026 at 11:53
Most AI comparisons miss the point—because the real differences only show up when you use them for actual work. After pushing both Claude AI and ChatGPT to their limits, some surprising patterns start to emerge. This isn’t about benchmarks, it’s about how these tools actually think, write, and collaborate when it matters.
❌
❌