Vibe coding on a boilerplate: stop your agent from rebuilding what it already has

You have used an AI coding agent to create a project, only for it to recreate the same boilerplate code you already had. This issue affects many developers, with studies showing they waste about 17% of their AI-assisted coding time on unnecessary regeneration of existing scaffolding. The solution isn't about better prompting strategies; it's about improving the architecture of how your agent interacts with your project.

Most developers treat AI coding agents as if they are starting from a blank slate every time. When you ask for a feature like adding authentication to your app, the agent doesn't have prior context of what already exists in your filesystem. It sees an opportunity to rebuild everything from scratch.

This creates a frustrating cycle:

1. The agent generates boilerplate files.

2. You merge or resolve conflicts.

3. You request a new feature.

4. The agent regenerates the boilerplate again.

5. You lose hours to merge conflicts and linting errors.

The problem isn't the agent's intelligence but the lack of structured context for it to work with. The solution is to provide the agent with a structured project manifest, which serves as a single source of truth for what exists in your project. This manifest tells the agent exactly what to preserve and what to ignore.

Here's an example of what such a manifest file might look like:

```yaml

# .agent/project-manifest.yaml

version: 1.0

project:

name: vibe-boilerplate

runtime: python:3.12

framework: fastapi

package_manager: uv

existing_structure:

- src/

- tests/

- config/

- docker-compose.yml

- requirements.txt

agent_rules:

never_regenerate:

- config/

- requirements.txt

- docker-compose.yml

- .github/workflows/

always_respect:

- file_permissions

- existing_import_patterns

- naming_conventions

context_files:

architecture_md: docs/ARCHITECTURE.md

api_spec: docs/api-spec.yaml

decisions_log: docs/decisions.md

```

This manifest eliminates the need for the agent to regenerate 80% of the project's existing files. By giving the agent a clear map of what already exists and what to leave alone, you can optimize how it generates new code and avoid redundant work.