Everyone talks about prompts. Everyone debates which model is better. But when you start working with AI agents in real software development, you quickly discover something far more important: none of them matter without context. An agent without context is like a senior engineer dropped into an unfamiliar codebase with no documentation, no environment setup, and no instructions. It can still do something, but it won’t be good.
At Nybble, that realization reshaped how we think about agentic development. Before we talk about what we delegate to agents, we have to think about how to prepare the ground. As Nybble’s Director of Technology and Innovation, Leo Rodriguez, often reminds the team, productivity doesn’t start with the prompt, but “when you prepare the project so the agent actually understands where it’s working.”
Context is the operating system that makes agentic development possible.This article explores exactly why context matters, how Nybble designs it, and why the future of agentic development starts long before the first line of AI-generated code.
Documenting for the AI: Giving Agents a Map of the Territory
When Nybble first began experimenting with agents, one thing became clear: agents work as well as the context they’re given. Humans can guess, infer, and fill in gaps. Agents can’t, at least not reliably.
So Nybble developed a habit: documenting for the AI.
This goes beyond a traditional README. It means creating files like AGENTS.md that explain:
- How the project runs
- How tests are executed
- Architecture decisions
- Dependencies and integrations
- Which parts of the system shouldn’t be considered
This documentation isn’t a nice-to-have; it’s fuel.
Leo puts it this way: “The documentation is no longer just for humans. It’s for agents too.” He states that agents need clear boundaries: “how the project runs, how it’s tested, what’s allowed and what’s not.”
Once an agent understands the context, its output stops feeling like guesswork and starts resembling real collaboration.
CI as Context: Teaching Agents the Rules of the Game
Context isn’t just text. Context also lives in the pipeline.
A strong CI pipeline becomes a guide rail system for agents: every commit triggers linting, testing, and quality checks. That feedback loop tells the agent what “good” looks like, and what breaks the build.
Leo captures this perfectly: “If every commit triggers linting and tests automatically, the agent learns the rules of the game. You don’t have to tell it every time your pipeline tells it what’s acceptable.”
In other words, CI becomes the environment where agents learn cause and effect. Over time, that structure shapes their “behavior” far more than any prompt ever could.
Plan Before You Code: Using AI to Think, Not Just To Type
Another shift Nybble embraced is planning with agents, not just coding with them.
Traditionally, developers jump from a user story straight into implementation. With agents, Leo argues for an extra step — a step that saves hours later:
- share the user story
- let the agent challenge it
- refine missing assumptions
- generate a detailed technical spec
- iterate until the spec truly represents the solution
Leo often emphasizes this point earlier in the process: “I don’t start coding until I’m happy with the technical spec. If you let the agent help you refine that first step, you save a lot of pain later.”
This is where Nybble uses thinking/planning models (capable of analyzing constraints, spotting inconsistencies, and anticipating problems) before switching to code-generation models.
It’s a small mindset shift: use agents to think first, type later. Planning models cost more, but they pay themselves back quickly through fewer iterations and fewer surprises.
Lab Mode vs. Production Mode: Context Depth Changes Everything
One of the biggest misconceptions about agentic development is that agents should be used everywhere in the same way. Nybble learned the opposite: context depth must match the stakes.
Lab Mode: Looser Context, Faster Learning
In early experiments — such as dashboards, internal tools, proof-of-concept features — Nybble uses a lighter version of context. The goal isn’t perfect code; the goal is speed and learning.
As Leo explains during internal sessions, “In the lab, we use agents to try things fast. It’s okay if the code isn’t perfect, because the goal is learning, not delivering a final product.”
This is where curiosity wins: quick prototypes, UI sketches, workflow ideas, even infrastructure experiments.
Production Mode: Context Becomes Non-Negotiable
When delivering real features for clients, the game changes. The SDLC doesn’t disappear — it gets enhanced. Agents operate within:
- strict documentation
- architecture guidelines
- CI/CD rules
- testing requirements
- security constraints
Leo is direct about the distinction: “For a serious client feature, you can’t work like you’re in the lab. You still use AI, but you use it inside a proper SDLC: with architecture, testing, and review.
Agents accelerate the work, but never replace the discipline and criteria.
If You Want Better Agents, Build Better Context
Across dozens of experiments and real projects, Nybble learned one fundamental truth: agents don’t become useful when the model gets smarter; they become useful when the context gets clearer.
To make agents work, you need:
- A documented environment
- A project structure designed for agentic collaboration
- CI/CD that gives immediate feedback
- Planning done with thinking models
- Guardrails for when you’re in production mode
Or in Leo’s words: “The goal isn’t to stop programming. It’s to prepare our projects so agents can help us reach a better result, faster, without losing quality.”
Agentic development begins long before the first prompt, and its success depends on everything you build before the agent writes a single line of code. When context is designed with intention, agents don’t just generate output; they expand what teams can create.
In the end, great agents are not magic, they are the result of great prep work. And that is where Nybble shines.
Better context leads to better agents, better collaboration, and better results. When it is designed with care, teams become stronger, delivery becomes smoother, and innovation becomes sustainable.
That is the remarkable future we are building at Nybble, one project at a time.