I Think AI Coding Tools Need a Shared Framework

Mohammad — Sun, 09 Aug 2026 10:19:06 +0000

I have been spending a lot of time using AI coding tools recently. They are surprisingly good at writing code, explaining unfamiliar parts of a project, and helping with repetitive work.

But I kept running into a problem that was not really about the model.

The problem was everything around the model.

Where should the instructions live? How should I organize reusable workflows? How do I share the same engineering standards between projects? What happens when I want to use a different AI coding tool?

That is why I started building @mohammadhprp/system-prompt.

The part that feels fragmented

Different AI coding tools have different ways of configuring agents. Some use instruction files. Some have skills, commands, plugins, modes, or their own configuration format.

The names and formats are different, but the needs are often the same.

I usually want my agent to:

Follow the engineering standards of the project
Use a repeatable process for common tasks
Remember useful project context
Connect to tools such as GitHub, a database, or documentation
Review its own work instead of only generating code
Work with fewer unsafe assumptions

I found myself recreating parts of this setup again and again. A new project meant another round of copying instructions, choosing tools, and deciding how the agent should behave.

That repetition made me wonder whether this should be a framework instead of a collection of unrelated configuration files.

The idea behind System Prompt

I use harness to describe the environment around an AI model.

The harness includes the instructions, tools, permissions, workflows, memory, integrations, and standards that influence how an agent works. The model matters, but the harness also has a big effect on the quality and safety of the result.

My idea is simple:

AI coding tools should be able to share more of the framework around the model, not only the model itself.

This is still an idea, not a finished standard. I am trying to understand which parts can be shared and which parts will always need to remain specific to each client.

Why MCP gave me this idea

The Model Context Protocol is a good example of what interoperability can look like.

Before MCP, connecting an AI application to an external tool often meant dealing with client-specific integrations. MCP provides a shared way to expose tools and context.

That made me think: could we use a similar approach for other parts of the coding-agent harness?

For example, could a skill describe a workflow in a portable way? Could an agent role declare its capabilities and permissions? Could a command work across multiple clients through small adapters?

I do not think everything needs to be identical. Different tools can still have different interfaces and user experiences. But the underlying building blocks could be described consistently.

What the package does today

System Prompt is an interactive CLI. It helps install selected parts of an AI coding-agent framework into a project instead of asking users to copy everything manually.

You can try it with Node.js 18 or newer:

npm install -g @mohammadhprp/system-prompt

Run it from your project directory:

system-prompt

The CLI lets you choose what to install. The framework currently includes:

Skills for repeatable procedures
Specialized agents for tasks such as research, architecture, code review, and security
Commands for common workflows
MCP documentation and configurations
Plugins and behavior modes
Project memory
Design references
Engineering standards and templates

The important part for me is that these are separate, documented components. I do not want one huge system prompt that an agent has to read every time. I want smaller capabilities that can be selected and used when they are relevant.

What a shared framework might need

If this idea grows beyond one project, I think a shared framework would need more than a directory of prompts.

It would probably need:

A common description format for skills, agents, commands, and integrations
Version and compatibility information
Clear permissions and capability declarations
Client adapters where formats are different
A way to validate components before installing them
A registry for discovering and sharing components
A way to preserve project context without locking it to one vendor

Security is especially important here. An AI tool may be able to read files, run commands, access a database, or change project state. A framework should make those capabilities visible instead of hiding them in a prompt or configuration file.

This is an experiment

I am not presenting System Prompt as the answer, and I am not saying that the industry needs one tool to control all AI coding agents.

I am exploring a direction that feels useful to me: a central, extensible framework for the harness around AI coding tools.

The project is open source and available under the MIT license:

I would really like feedback from people who use AI coding agents regularly.

Which parts of your setup do you keep recreating?
Do you switch between multiple AI coding tools?
What would you want to be portable between them?
What should a shared framework guarantee before you would trust it?

The question I keep coming back to is this:

If MCP can give AI applications a shared way to connect to tools, can we also create a shared way for AI coding agents to operate inside software projects?