5 Pillars of Augmented Agentic Software Development

I’ve been experimenting with several AI coding assistants, today more formally referred to as “agentic coding”, such as Gemini CLI, Claude Code and Cursor as some popular examples. With a growing experience around optimizing for the best results from LLMs for both large and existing code repos as well as greenfield new npm packages, I’ve taken several key pillars that help augment the performance you get out of agentic workflows for software development.

Following is an outline of these agent-focused pillars:

1. The Agent system instructions

Just as chatbots like ChatGPT have an internal “system prompt” for alignment and grounding of their behavior and scope, so do agentic coding tools.

Specifically, with regards to CLI coding tools, which have been mostly popular in adoption by developers who seek autonomous execution and are running on the user’s premise, those system prompts are significantly important to steer the type of work you wish to do within software development.

Originally, they’ve been proposed by other agentic IDEs like Cline (or Roo Code) and Cursor and have been made popular by the latter as “cursorrules”. Now, they’ve been popularized as agent markdown files. I call them Agent MDs:

• Claude Code uses CLAUDE.md
• Gemini CLI uses GEMINI.md

They behave differently but regardless, are great to adopt. For example, Claude Code looks up for CLAUDE.md file in the current directory where it executes coding tasks and traverses up until it finds one in the project’s root directory (or a user global configuration at the home directory ~/).

How to use those Agent MD files:

• Put project general overview in them
• Keep track of design and technical considerations
• Describe services and models in specified directories. For example, if you have a src/services/database you can put a CLAUDE.md there that would outline relevant information for any work that the agent will do with your database service. For example, if you don’t want the agent to hallucinate non-existent tables or disallow creating composite primary key on the database level, simply outlines these instructions in the markdown file. This way, you can be very specific in your instructions per the directory structure and avoid a large context outlining these in just one file.

2. Spec-driven development

What started as “prompt engineering” has now evolved into “context engineering”.

Gone are the times where you prompts “build a note taking app” and enter the days of spec-driven development, where you outline high-level product requirements (and may take further steps to provide a design document as well).

To use the note taking app example, you’d likely create a docs/ directory that will hold a REQUIREMENTS.md doc file that will outline information that you’d normally find in a PRD (Product Requirements Document) such as:

• Overview
• Product’s goal
• Product’s dependencies
• Product’s functional requirements
• Use-cases and user acceptance criteria

Here is a real example from a command-line app I’m building called agent-rules:

- docs/
   - REQUIREMENTS.md
   - DESIGN.md
   - PROJECT.md

I invite you to also into the code repository and investigate the other docs fully to grab a broader understanding on how to build these.

Ok so if we’ve made the case for spec-driven development, how to take it forward from here? Here are some tips I have for you to explore:

• If you’re working on an existing project with code-base already established, invoke Gemini CLI or Claude Code and prompt them to create one of these documents. Give them examples and references and fine-tune your prompt with what you are looking for.
• As part of your agentic coding workflow, when you finish working on a task, require the agent to update those requirements and/or design documents with the relevant information from the task so that these documents stay up-to-date resource for the next task.
• Explore AI-native spec-driven development platforms like Tessl which primarily optimize for a high-level guided PRD workflow.

3. MCP Servers to speed-up and augment LLMs

So everyone have been MCPing and MCPs have become ubiquitous. Whether these are WorkOS’s MCP Night events, or front-and-center talks at AI Engineer conference, and really just so immensely popularized and pushed by Anthropic and other key players in the LLM and agentic workflows space.

If you’re new to MCPs and need an introduction then I’ll skip it here but will leave you with my prior guides on “What is MCP in AI” and “A Visual Introduction to Understanding MCP” for you to deep-dive into.

Alright, back to MCPs with coding agents. LLMs are a great knowledge base but they lack very specific and up-to-date information about libraries you use, or actions you want to perform. This is where MCPs come in handy to really augment the coding agent and I’ve been using the following group of MCPs to really augment the performance:

Code research MCPs

DeepWiki is a website that indexes GitHub projects and creates a sort of Deep Research around code repositories.

If you want to deep-dive into a library, you could read the code, which is… hard to navigate and consume. But DeepWiki create an entire structure out of this, including core component architecture, flow charts, getting started and more.

A picture is worth 1,000 words, so here is an example from DeepWiki website analyzing my lirantal/npq project which is about my npq security CLI:

Other notable code research and library documentation MCPs:

1. GitMCP for on-demand, live and library-specific MCP documentation
2. Context7 which is somewhat similar to GitMCP but GitMCP could be viewed as more secure as it doesn’t pre-index data that could be malicious.
3. Node.js API Docs MCP Server which is an MCP Server for Node.js API documentation

Code vitality and security MCPs

LLMs are token hungry and agentic coding assistants are even more so. They’ll read a lot of context and you’ll likely be creating so much more new code and at an unprecedented pace like never before.

How do you make sure the new GenAI code is up to your standards?

• Is the new up to our coding style and standards? Run the ESLint MCP Server (or have an agent rule to always run npm run lint for example)
• Is the new code free of security vulnerabilities? Run the Snyk MCP Server

Web research MCPs

Tired of the context switch between your IDE code and googling, eh, remember those days? :)

Regardless of the model’s knowledge base you sometimes want to research a topic before you even plan it. Now you can do it with dedicated deep research or search MCPs in the form of Exa and Serper (Google search results).

Exa, Serper and other MCP services that allow you to search the web right from the agent’s chat window without having to switch back and forth from your browser window to the IDE or terminal.

In fact, Gemini CLI bakes in a built-in web search capability so if you’re stuck on an error you’ve never seen before you can just search for the error code:

4. Agent Sessions and Memory

Some more advanced traits of augmented development include keeping track of tasks progress which provides insightful and up-to-date context about work on this code repository.

Why is managing on-going memory useful for agentic coding?

• The agent keeps a sort of task-list of its work. It can even manage an actual markdown task list via [ ] Create a database schema type of tasks and then update them as it goes along.
• Agent memory helps you manage asynchronous work on a code base so you can pause and resume at any time.
• Agent memory is useful to roll back changes or do a time travel visit to prior work.

Some notable examples of using agentic coding memory are the Task Master AI tool, and Philipp Schmidt’s Plan mode for Gemini CLI:

5. Agent Commands

Interested in squeezing out the most out of CLI coding agents? Claude Code and Gemini CLI allow you to extend the out-of-the-box CLI behavior with the following (not all features exist in both of these coding agents):

• Hooks: for example, before or after editing or reading files, run command x.
• Commands: expand the slash commands with your own.
• BYOM: Bring Your Own MCP allows you to connect MCPs that extent the agent’s capabilities.
• Rules / System prompts: Building your own rules such as the CLAUDE.md and GEMINI.md that we’ve described above.

Some of these are even bundled together as full end-to-end extensions that you can enable for the agent.