# No Baked-In Behavior: Why Your AI Agent's System Prompt Should Be Yours > Source: > Published: 2026-07-11 19:45:26+00:00 Every AI coding agent ships with baked-in behavior. Hidden system prompts you can't see. Tools you can't remove. Steering baked in by the company that made it. It's just how these products work. Batteries included. Claude Code has a system prompt. A long one. It tells the agent how to behave, what to prioritize, what to avoid. It's not exposed in the product. You can dig it out of the npm package if you know where to look, but you can't change it. Cursor has tool definitions and behavior rules that shape every interaction. Copilot has its own set of baked-in instructions. And these prompts are *good*. They're written by smart people who understand the model. They make the agent useful out of the box. But they're not yours. I think we've all been there. The agent does something weird and you don't know why. Was it your prompt? Something you can't see? A tool description that's steering the model in a direction you didn't ask for? You're debugging a black box. Here's what actually happens: **You can't debug behavior.** The agent does something unexpected and you have no way to trace it back to the instruction that caused it. **Your prompts fight theirs.** You say "always use pnpm" and it uses npm anyway. Why? Because somewhere in the baked-in prompt, something overrides your preference in certain contexts. You can't find the conflict because you can't see the other instruction. **You can't remove behavior you don't want.** Maybe you don't want it to run tests after every change. Maybe you don't want commit suggestions. If it's baked in, you're stuck. **You can't tell what's the model and what's the product.** Did the agent recommend that library because it's good, or because a baked-in instruction told it to? You can't distinguish model knowledge from product steering. Jean2 ships with **no default system prompt**. No default tools. No fixed agent personality. The binary is blank by design. When you start a session, the system prompt is composed from pieces *you* control. Let me walk through each piece. A preconfig is a saved agent configuration: model, tools, prompt, skills. The system prompt in a preconfig is *the* core prompt for that agent. You write it. You see it. You change it. No hidden instructions. What you write is what the agent gets. Every workspace can have an `AGENTS.md` file at its root. Project-specific instructions, included in the system prompt automatically: ``` # AGENTS.md ## Build Commands - `bun run build`: build all packages - `bun run test`: run all tests ## Code Style - Use `import type` for type-only imports - 2-space indentation - Single quotes for strings ## Don't - Don't modify packages/sdk/src/version.ts without updating the version - Don't run the server without asking first ``` It's version-controlled with your code. Anyone on your team gets the same instructions. The workspace `MEMORY.md` . Facts the agent learned and saved. "We use pnpm", "the database is SQLite", "tests run with bun:test". Tell it once, it writes it down, it knows forever. Your personal agent memory. `USER.md` and `MEMORY.md` from the agent's home directory. Preferences and knowledge that travel with the agent across projects. Any skills the agent loads. Skills are playbooks: deployment checklists, code review standards, debugging workflows. Written by the agent, or by you. Here's what the prompt assembly actually looks like: ``` [Preconfig System Prompt] ↓ + [AGENTS.md from workspace root] ↓ + [Workspace MEMORY.md] ↓ + [Agent USER.md + MEMORY.md] ↓ + [Loaded Skills] ↓ + [Session Search guidance + Skill management guidance] ↓ = Final System Prompt sent to LLM ``` Every piece is a file on disk. Readable, editable, version-controllable. No hidden layers. Let me give you a concrete example. I was using a coding agent (not Jean2) and it kept adding `console.log` statements to debug code. Every session, same thing. I'd tell it not to, it would agree, and 20 minutes later there's another `console.log` in my codebase. I couldn't fix it because I couldn't see what was causing it. With Jean2, if the agent does something I don't want, I can: With a baked-in agent, you can't do step 1. You can't see the prompt. You're guessing. Here's the fair pushback: most people don't want to write system prompts. They want an agent that works out of the box. True. That's where **preconfigs** come in. A preconfig is a starting point. You can create one for coding, for research, for review. Someone can share a preconfig. A team can maintain a standard set. The difference is that the preconfig is *visible and replaceable*. You can see exactly what instructions the agent has. Change any of them. Throw the whole thing out and start from scratch. Baked-in means you can't. Preconfigs mean you can. Here's a simple test. Ask your current AI agent: "What's in your system prompt? What instructions are you operating under right now?" Some will refuse to answer. Some will give a vague summary. Some will hallucinate. Almost none will show you the actual prompt. In Jean2, the answer is: check the files. It's all files on disk. You can read every word. Diff it between versions. Share it with your team. Jean2's approach isn't for everyone. If you want a turnkey coding agent that works perfectly the moment you install it, with zero configuration, Jean2 isn't that. Yet. But if you've ever been frustrated by an AI agent doing something you can't explain, can't debug, and can't change, Jean2 is built for you. Every layer is yours. Every prompt is visible. Every behavior is configurable. No company can switch off a feature because of your region. There's no server to enforce from and no telemetry to check with. Your tools on your computer should be yours. [Try it out](https://jean2.ai) or [join the Discord](https://discord.com/invite/38sUKnUNPQ). I'm [@danielbilekq0](https://twitter.com/danielbilekq0) if you want to argue about it. *This post originally appeared on jean2.ai. Star the project on GitHub.*