# I Built Stack2Rules: Generate a CLAUDE.md for Your Project Automatically, Looking for Developers to Test It

> Source: <https://dev.to/shadowsama20/i-built-stack2rules-generate-a-claudemd-for-your-project-automatically-looking-for-developers-1ofh>
> Published: 2026-11-10 01:36:46+00:00

Hey DEV Community! 👋

I've been working on an open-source Python developer tool called **Stack2Rules**, and I'm excited to share its first public release.

The idea is simple:

**What if you could generate a project-specific `CLAUDE.md` file automatically, without manually writing instructions for every framework in your application?**

That's what Stack2Rules aims to do.

It's now available on GitHub and PyPI, and I'd love feedback from developers who work with Python, JavaScript, TypeScript, and AI-assisted coding tools.

AI coding assistants can benefit from clear, project-specific instructions.

But every project is different.

A Django backend has different conventions from a FastAPI application. A Next.js project has different architectural considerations from a React application using a separate backend.

Writing and maintaining these instructions manually takes time.

I wanted a lightweight tool that could inspect a project's declared dependencies and generate a useful starting point.

Stack2Rules is a zero-runtime-dependency Python CLI that:

`CLAUDE.md` file.
It is an independent open-source project, not an official Anthropic tool.

Stack2Rules requires Python 3.11 or newer.

Install it using pip:

```
python -m pip install stack2rules
```

Navigate to the root of your project and run:

```
stack2rules
```

That's it!

The tool inspects supported dependency manifests and generates a `CLAUDE.md` file in your project directory.

You can also target another directory:

```
stack2rules --dir /path/to/project
```

Or specify a different output filename:

```
stack2rules --output CLAUDE.generated.md
```

Existing output files are never overwritten.

Stack2Rules examines three root-level project files:

`package.json`` requirements.txt``pyproject.toml`
It identifies supported packages from their declared dependencies and selects appropriate instruction templates.

The current release supports 17 technologies, including:

**Python ecosystem:** Python, Django, FastAPI, Flask, Pandas, NumPy, Pydantic, SQLAlchemy, and pytest.

**JavaScript and web ecosystem:** Node.js, React, Next.js, Vue, Express, TypeScript, Tailwind CSS, and Vitest.

For example, a Next.js project using React, TypeScript, and Tailwind CSS can receive dedicated guidance for each recognized technology.

The generated instructions encourage version-aware development rather than assuming which framework version is installed.

Before publishing v1.0.0, I wanted to establish a reproducible baseline.

The repository includes a documented validation record showing:

These results are encouraging, but they don't replace real-world testing on diverse developer projects.

Full validation details:

Because Stack2Rules examines project manifests, I wanted to keep its behavior limited and predictable.

The tool:

`.env` files or private keys.
These are intentional design choices, although the tool is not intended to function as a security sandbox.

The first public release is available now.

**GitHub Repository:**

[https://github.com/Shadowsama20/stack2rules](https://github.com/Shadowsama20/stack2rules)

**PyPI Package:**

[https://pypi.org/project/stack2rules/](https://pypi.org/project/stack2rules/)

**Version 1.0.0 Release:**

[https://github.com/Shadowsama20/stack2rules/releases/tag/v1.0.0](https://github.com/Shadowsama20/stack2rules/releases/tag/v1.0.0)

The project is released under the MIT license.

This is where I'd really appreciate the DEV Community's help.

I'm particularly interested in feedback about:

**1. Real-world compatibility**

Does Stack2Rules recognize the technologies in your project correctly?

**2. Missing frameworks**

Which additional frameworks or tools would make it more useful?

**3. Quality of generated instructions**

Are the rules helpful, accurate, and sufficiently specific?

**4. Edge cases and reliability**

Can you identify cases where detection fails, produces misleading rules, or behaves unexpectedly?

**5. Code quality and architecture**

Are there opportunities to simplify the implementation or improve maintainability?

If you find an issue, please open a GitHub issue with a reproducible example.

Contributions are welcome, including documentation improvements, new framework mappings, test cases, and bug fixes.

My immediate priority is collecting independent feedback and testing Stack2Rules against more real-world projects.

I'd like the next improvements to be driven by problems developers actually encounter, rather than simply adding features without evidence that they're useful.

Stack2Rules is a small open-source project built around a straightforward idea: make it easier to give AI coding assistants useful, stack-specific project instructions.

I'm proud to have reached the first public release, but I know that releasing software is only the beginning.

**If you use AI coding assistants, would automatically generated project instructions help your workflow? What would you change about this approach?**

Feel free to try Stack2Rules, explore the source code, open an issue, or submit a pull request.

And if you find it useful, consider starring the repository to support the project.

Thanks for reading! 🚀