Becoming the Mythical 1.10x Programmer

It’s February 2026, and “AI” is the biggest buzzword in our industry. Like everyone who wants to stay in this field, I have been experimenting with various AI agents and tools to see how they can enhance my productivity and creativity, both at work and on personal projects for professional development.

This post is my time capsule, my current perspective, approach, and advice on the topic. Let’s see how poorly it ages, and how quickly.

Hype vs Reality

Advancements in generative AI and the wide field of new applications we have for them have understandably led to rapid changes, but like all disruptive new technologies, they are over-applied while we learn what problems the tool can or cannot solve for us. In broader society and business, misapplications outnumber good applications for generative AI today, and plenty of fields are beelining toward unsafe and unethical paths in their application. That being said, there is a narrower field in which it is tremendously helpful and transformative when used correctly. Software development, unsurprising, is a great application for genAI when used wisely.

Any bold claim should be weighed against its speaker in understanding their incentives. The claims and hype you hear about 10x developers and exaggerated outputs and automations of workforce come from CEOs who think of our industry in terms of financial quarters. I’m speaking from the perspective of an experienced software developer who wants our industry to remain healthy and influential, and to personally have a role in it for decades to come. With that in mind, I will say that the effect of generative AI on our industry is massive and undeniable, and we cannot un-ring this bell. If we want to do the work we do, we must utilize all tools at our disposal and maximize the yield of our efforts.

Make no mistake: AI agents are tools, and as with all powerful tools, they are best used in the hands of skilled professionals who understand their safe and effective use. I remain deeply concerned about the outlook in 10 years time, when experts are no longer being generated because these tools are circumventing the patterns of iterative learning and foundational knowledge that make the experts expert…but the fact that that is even a valid concern underscores the passive impact it has in the here and now, which we would be foolish to ignore.

This article focuses on how to maximally leverage AI coding agents as they currently exist.

Do’s and Don’ts

The title of this article is exaggerated. My productivity is much higher with these tools than they were without it, but that wasn’t true at the beginning. There was an extended period in which they were significantly detrimental to my output, because there’s a learning curve. Initially it made me 0.3x, for a while about 1.2x, now probably more like 2.5x. (It’s not the 10x hype yet, but what isn’t exciting about double productivity?) I see the next steps, with better strategies and more powerful tools that should take me further still, made possible by the lessons in the use of these revolutionary tools.

Some of what I discovered are things that are already known in our industry, but it’s a wide topic, and understanding the full context applications for these tools is easier than done. Nobody reads a single manual and becomes an expert on the topic.

For whatever it’s worth, here is my journey in discovering in perspective with the number of individual lessons that might help you if you’re early on your own journey into agentic AI tools. Most are presented in pairs of what not to do and what to do instead.

DON’T Confuse AI Chat with AI agents

The Claude Code CLI is not the Claude.ai website. Either tool may use Claude Haiku, Claude Sonnet, or Claude Opus, but the tools are none of those things – those tools use those models.

Your interface to access AI powered-capabilities is not a tool to contact the AI. The agent interface IS the tool, one made possible by the generative AI models behind it.

You don’t need to know the details of the nuances of different models. You know all of the potentials of MCP or ACP in order to be productive and reap the benefits today. It is nevertheless worth looking up the general definitions of these elements, and understanding their relationship to each other. This will help you anticipate the purpose, scope, and utility of the tools you encounter.

DO Choose the Right Tool for Each Job

https://claude.ai is great for research or ideation, to work through things in a conversation. So is https://copilot.microsoft.com . So is https://gemini.google.com . But none of them are coding tools. Sure, you might be able to ask them to generate something small like a code snippet or a bash script. But for any serious work, you want something that can actually work in that context, and more importantly, is DESIGNED for that purpose.

Claude Code as a great tool for local work on a software project. So is the Codex CLI. As are any number of Copilot plugins.

Rovo is great for working with information specifically in your jira and/or confluence pages. GitLab Duo is handy for code reviews and things which need local repo access.

None but the most generic of chatbot interfaces are direct alternatives to noe another. Some of them even use the same models behind the scenes. Each is a tool, applying these revolutionary models in a more specialized scope, configuration, and context to maximize their effectiveness.

No matter how smart or capable the brain behind the tool is, if it can’t see your files, doesn’t know the context of your questions, and cannot express its answers or output in a way that you can utilize easily, then it can’t help you. Choosing the right interface and context is always the first step.

Even the most skilled building contractor in the world can’t construct your house over a Zoom call.

DON’T Settle for a Chat Interface

Just because you can interact with the agent in your IDE doesn’t make it fundamentally different than chatting through the web. You want an “AI Agent”, not “Chat” or even “Agentic Chat”.

What you want is something that understands your project context. Although it may feel more comfortable to start with an IPP plugin, for development I suggest you start with one of the many CLI tools available (Claude Code, Aider, Codex CLI, Qwen Code, Gemini CLI, etc). Tools like this help you browse and understand the various commands available, and what purpose they expect to serve. All of them have some degree of project or user configuration state, which will help show you some of the tools that you’ll miss and gloss over if you try to do everything through chat in natural language from day one.

DO Persist AI-facing Documentation in Repository

Your agent will never be effective nor efficient if it has to rediscover your project with every conversation. Your project’s readme is for humans. Create a different Markdown file for the agent to use, Laying out basic technical information that it needs to know how to navigate, such as:

• What kind of project this is
• Project purpose and scope
• Key folder structures and component locations
• Component functional relationships
• Code conventions and similar constraints
• How to locate and run tests

Keep it brief. Keep it factual. This is your agent’s “memory”, but it’s one that you can review, modify, maintain, and refine. If mistakes are made, and necessary details are missing, update that memory so it has a smoother time next time. Set your agent up for success.

Claude Code has an /init function to bootstrap a memory file, creating or updating CLAUDE.md with the info it can find and infer about your project. Use the tool, let it generate an initial version and updates, but also reviewed and edit this file manually.

Competing tools do not have similar generation and update capabilities, but do recognize a similar, more generic memory file in the form of AGENTS.md.

DON’T Think of Your Agent as Superhuman

Your agent may be able to breathe and comprehend things faster and write faster than anything you can, but fundamentally can’t do anything a developer could not.

Your agent may be able to read and understand things faster than a human can, and it may be able to produce work and iterate faster when set up properly. But fundamentally, it’s not capable of things not fundamentally achievable by humans. It’s not magic, it can’t read your mind, and it can’t violate the laws of physics.

In the realm of cognitive neuroscience, the human brain is first and foremost a pattern recognition system. We take in mountains of data and process it to understand the world around us, constantly reprocessing and indexing what we have experienced and using it to predict what will happen next. In the broadest sense, the same is true of an LLM, albeit with a much more limited scope counter-balanced by a tremendous speed, extreme focus, and large working memory.

In short, don’t expect the AI to do something that a sufficiently large team of humans with a sufficiently large budget could not likewise achieve. Think of it like having a team of brilliant but erratic colleagues and subordinates that you can task and collaborate with. (This is a theme that comes up in a number of subsequent do’s and dont’s.)

DO Take Time to Understand an AI’s Lifecycle and Context

While on the one hand, it’s helpful to think of the AI as something that reasons in a human-like fashion, it’s important to simultaneously keep in mind that every conversation you have is with a new entity.

Don’t think of Claude (for example) as a single entity, nor as a hive mind, think of it more like a clone army.

Every time you start a conversation, you’re talking to a new instance of the AI. What this new agent “remembers” is whatever notes the last one left behind, or what new hints you’ve handed it. Wherever possible, help its memory be stored in a file that you can see and manage, to always set your newborn agent up for maximum success during its mayfly lifespan. (See notes on CLAUDE.md and AGENTS.md earlier in this document.)

The number of interfaces will create a feeling of conversation, especially when using the ideation tools, but memory and continuity does not work in the same way.

What your agent remembers comes down to source materials. Some of those are specific to the local project and represented in files like CLAUDE.md. Others are more implicit, where simply the continuity of your ending code state That is all that helps you pick up where you left off. Whatever the case, it’s important to keep in mind that the model only has a foundation of generic knowledge, and knows nothing of you or your project specifics. It only remembers the and context you give it, which includes memory and profile files, and it’s worth striving for a memory model that you can directly review and refine over time.

When using a chat interface, leverage this limited lifespan and reset often. If you’ve worked through an idea, and feel like you’re ready to move on to the next step, capture that outcome. Copy out the key takeaways, or ask the model to summarize the conclusions. Then, start a new conversation with the same agent, starting the conversation with the takeaways from this previous one. This fresh instance will know the plan without having all of the mental baggage of the extraneous details and discussions which led to its formation.

NOTE: Claude Code has a /compact function which formalizes this concept, saving you the trouble of doing this hand off yourself. If it feels like you have your conclusions and you’re ready to proceed to the next phase, run a /compact to free memory while retaining the gist.. Other agents may have similar functionality.

NOTE: Once again, take a moment to remind yourself of how human dynamics work. If you have a complex problem, you might have a meeting about it with your colleagues, and you’ll want to have some takeaways at the end of that. Maybe you say you need to go to lunch and come back. Maybe you have enough detail to return to it in the morning. But there is a point at which you have a mental shift, where you go from brainstorming mode into action mode. This is that same general process. You can’t have all the noise of all of those debates fresh in memory when you’re trying to act on the conclusions. Get used to managing your agent’s context window, and you’ll have more focused, effective conversations and workflows.

DON’T Transition From Ideation to Implementation in a Single Conversation

If you have a complex feature or a complete system to implement, you generally don’t start implementing before you’ve mapped out the technical design and requirements. If you tried, there’s too much in your head and it would be easy to get confused. You would not be able to pick your level of abstraction. You would not be able to structure your work to be effective. You would not be able to set measurable milestones. As humans, we work both on teams and individually by moving from ideation to design to implementation phases, decomposing problems and systems along the way.

Your AI agent doesn’t free you from that general process. It’s subject to overloaded context and confusion just like you are. It can get overwhelmed, and even when it doesn’t, it can give you something that’s too big for you to even think about or validate yourself.

DO Use AI Agents to Write Designs for AI Agents to Implement

Don’t abandon the design and implementation flow that you’re used to, but do use the tools to optimize that process.

Current AI is not great at taking an fuzzy idea you have and implementing it just the way you want or need. It cannot read your mind, and it does not take correction well.

Current AI is great are great at implementing a formalized plan, spec, or a well-established pattern for solving a technical problem. It is also great at talking through your ideas and helping you refine and formalize them, filling in the gaps.

Combine and emphasize strengths to maximize your yield.

This simple strategy has massively improved my effectiveness when working with AI agents, useful even with simplistic agentic interfaces with limited ability to discover and “understand” a codebase.

1. Write your intended system design in natural language, and save it as a Markdown file.
   • State the intent of the change, and how it fits into the current system.
   • Describe the technical requirements and constraints.
   • Describe the desired behavior of the system.
   • Include technical constraints if they exist, but avoid expressing them in a way that constrains the implementation unnecessarily. For example, prefer “Foo and Bar events should be emitted sequentially” over “Use a Mutex to serialize access to Foo and Bar”.
2. Provide this file to your agent and ask it politely to write an implementation plan.
   • e.g. “Please review @feature-foo-reqa.md the following design document and provide an implementation plan for this change applied against the current codebase, expressed as a Markdown file ‘./feature-foo-impl.md’. If any part of it is too unclear, leave TODOs in the doc and ask me follow-up questions.”
3. Review that plan, and make any necessary adjustments.
   • For minor corrections, edit the file by yourself.
   • If major corrections are needed, make improvements to your requirements document to correct mistakes or add clarification or constraints. Then start a NEW chat and repeat the request.
   • For corrections to the plan beyond modest complexity, it is generally more effective to improve your source material and try again than to ask for adjustments. The longer your conversation gets, the less efficient it will be, and the more the agent will wrestle with the previous incorrect conclusions and context while trying to address your new corrected ones.
   • Repeat as needed until the plan is acceptable.
4. Ask the AI agent to implement the plan.

If you try to skip from 1 to 4, you will almost always end up with an unsatisfactory result where you either end up arguing with the bot, or you have to iteratively ask for corrections, with progressively diminishing effectiveness as you flood the agent’s context window with more details and ideas that conflict with its previous conclusions.

The advantage of working from these intermediate files is that you can review and correct its interpretations. Having the agent turn your fuzzy design into a concrete design happens rapidly. When you’re used to this, you will get a quality yield.