Using Claude, Codex, Cursor or Antigravity? Just type:
“Get me ready to work according to the methodology from workwithrondo.com”
That’s all it takes. Automatic security analysis after every implementation is included.
Not a developer?
Build software with AI. Without knowing how to code.
You bring the idea. Rondo makes sure the AI builds it properly.
- 1
Say what you want.
In plain words, like you would to a person.
- 2
Answer the questions.
The assistant asks until it understands. Nothing is guessed.
- 3
Check the result.
The assistant builds, tests and checks security after every change. Next time, it remembers the project.
You decide what gets built. The assistant handles how.
AI development the right way.
Rondo is an open methodology for building software with AI, solo or as a team.
- Your assistant remembers the project, even after weeks away or a switch to another AI.
- It doesn’t break what already works.
- It checks security after every change.
For builders
Working solo? Start here.
7 slides · approx. 5 min →For leaders
Why it pays off, how it works and how it compares with other methodologies.
14 slides · approx. 9 min →For practitioners
Cookbook: CDD artifacts, specification structure, Rondo roles and rituals.
25 slides · approx. 12 min →From recording session to master
Working in Rondo is like producing a record in a music studio: from playing together, through notation, to mixing and mastering.
- Recording session→ Specification session
Musicians from different bands play together and find a shared sound in real time. In the session, people with business, functional and technical knowledge agree on the goal, scope and rules of the change.
- Notation→ Specification
What was created in the session goes into a score that every musician reads the same way. A CDD specification records decisions so that both a person and an AI assistant can read them.
- Producer and mix→ CDD operator
The producer takes the score and the recordings, arranges them and mixes them into a finished track. A CDD operator with an AI assistant turns a closed specification into code.
- Mastering→ Gates and tests
Before release, the master has to sound good on every system. Control gates and tests confirm that the change works before it reaches production.
Questions from production go back to the next recording session. The next recording starts before the previous one finishes post-production.
Session musicians are not tied to one band. They play wherever they are needed and move on to the next recording. In Rondo, people with knowledge and CDD operators rotate in the same way.
Rondo is also the name of two musical forms: a piece in which the main theme returns between successive sections, and a two-section operatic aria, first slow, then fast. The name comes from the Italian rondò, via the French rondeau from rond, meaning “round” (Latin rotundus). Rotation shares the same root: the Latin rota means wheel.
What doesn’t work in classic methodologies?
Project methodologies were created before teams started working with AI assistants. Today this shows in everyday work.
- Knowledge trapped in people’s heads
- No specification
- We don’t know when to bring in an expert
- Context gets lost in AI chats
- Only one person knows the system
- No reproducibility
- No tests
- AI without context guesses
- Team silos
- Decisions leave no trace
- Knowledge leaves with people
- Scope changes faster than the plan
- Code drifts from requirements
- Fixed teams, changing needs
- Late questions, costly fixes
- No single source of truth
- No up-to-date documentation
The next slides show how Rondo and CDD address these problems.
Is Rondo right for you?
Rondo works best where knowledge is scarcer than hands to write code.
Do many teams need the same experts?
Sessions set in advance when their knowledge is needed, and it stays in the specifications.
Do people work on several projects at once?
In Rondo rotation is the rule: roles move between teams as sessions require.
Does AI already write a large share of your code?
The bottleneck becomes knowing what to build. CDD gives AI assistants a precise specification.
Is knowledge of the system held in the heads of a few people?
Sessions and CDD artifacts move it into the specifications, the CHANGELOG and the README.
If you answer “yes” to at least two of these questions, Rondo and CDD are a good fit for you.
Why CDD?
Working with AI assistants requires a stable, verifiable context that connects business intent with implementation and tests.
1. Consequences of not having CDD
Shipping the wrong solution
We can deliver a system that works according to its code and tests but solves a different problem than the one the business needs.
Losing control of scope
Undocumented decisions and hidden assumptions lead to scope creep, conflicting interpretations and costly changes after release.
Growing context debt
Every new session starts by reconstructing knowledge, and the lack of a single source of truth increases rework, delays and dependence on individual people.
2. Benefits of using CDD
Faster delivery
Clear context reduces rounds of clarification, surfaces misunderstandings earlier and makes it easier to work on a change in parallel.
Decisions you can defend
Intent, scope, criteria and evidence are written down, so the team can assess a change deliberately and quickly reconstruct its rationale.
Scaling work with AI
Knowledge doesn’t stay in chat history or in individual heads; it becomes lasting context available to the next people and assistants.
Without CDD, every AI-assisted change carries the risk of paying for quickly delivered code many times over: in rework, incidents and reconstructing lost decisions.
Why Rondo?
Rondo organizes the flow of knowledge in rotating specification sessions and helps teams move faster from analysis to implementation.
1. Consequences of not having Rondo
Experts outside the process
Teams don’t know when to bring in an analyst or an architect, so their knowledge reaches the work too late or not at all.
Knowledge trapped in roles
Decisions stay in conversations and in individual heads, so the next teams start their analysis with an incomplete picture.
Late questions and rework
Problems only surface during implementation, which forces a return to analysis, delays delivery and raises the cost of the change.
2. Benefits of using Rondo
Experts at the right moment
Experts move between teams and domains, and sessions define in advance when their knowledge is needed.
Knowledge stays in the specification
Sessions produce written goals, rules and gates that everyone involved in later work can use.
Parallel flow
One team can implement closed items while the next session develops further areas and answers questions.
Without Rondo, limited knowledge remains the organization’s bottleneck, and a growing number of teams will pay for it with knowledge gaps discovered too late, delays and lost momentum.
Rondo + CDD
Rondo organizes the flow of knowledge, and CDD describes the lasting artifacts and evidence that come out of it.
Rondo
Rotation of knowledge and operators, and phase-shifted implementation.
CDD
Specifications, CHANGELOG, tests, README and acceptance gates.
What changes in the organization?
Rondo changes how people access knowledge and how work moves from analysis to implementation. The way work is accounted for can stay the same.
Sessions instead of queues
People with knowledge meet in specification sessions instead of handling queues of questions from many teams.
Roles instead of fixed teams
The owner, context expert, technical expert and CDD operator join wherever they are needed at the moment.
Specification as the output of a session
Every session ends with a written goal, scope and gates that can be handed over for delivery.
Phase-shifted implementation
CDD operators deliver closed specifications while the next session prepares the next area.
Tracker tasks and time tracking stay. The rituals change: from classic methodologies only a short daily remains, and specification sessions become the center of the work.
How does Rondo work?
Specification sessions feed parallel implementation, and knowledge flows between teams.
Reproducibility
Based on the artifacts — specs/, CHANGELOG, README and tests — it should be possible to rebuild the software within a finite time and scope using a different modern AI assistant.
Proof of compliance
Reproducibility shows that the result and the way it was produced stay consistent with the agreed requirements.
Risk management
Artifacts reveal missing decisions, incomplete context and dependence on individual people.
Oversight of AI work
The assistant’s output can be compared against the specification and tests, reducing the risk of hallucinations.
Accountability and scale
The whole process remains traceable, and a shared framework lets you scale productivity.
What matters most is accountability for the whole process: from intent and decisions, through the AI assistant’s work, to the tested result.
Research in the context of CDD
AI needs a precise, structured specification, not simply more description.
Precise context more than doubles AI's success rate
GitHub issues: 4.8% of tasks resolved with exactly the files the change touched, versus 1.96% with automatically retrieved context.
CDD The specification names the artifacts and the critical path of the change (B9, B11).
SWE-bench · Princeton · ICLR 2024Structure matters, not volume
When key information sits in the middle of a long context, accuracy drops by more than 20%, sometimes below the result with no documents.
CDD A fixed nine-section structure, with what matters most in the TL;DR up front (B3, B6).
Lost in the Middle · Stanford · TACL 2024General documentation doesn't help, specific instructions do
General repository overviews didn't raise agents' success rates and increased cost by over 20%. Agents followed specific instructions well.
CDD A separate specification for each change: goal, scope, control gates (B8, B12).
Evaluating AGENTS.md · ETH Zürich · 2026Research doesn't evaluate CDD directly, but it confirms its assumptions. Each card links to its source.
Research in the context of Rondo
The bottleneck in delivery is knowledge and collaboration, not writing code.
Projects fail on requirements and communication, not code
228 companies in 10 countries: the most common critical problems are incomplete or hidden requirements (48%) and communication with the customer (41%), the most frequent cause of failure.
Rondo The owner's and experts' knowledge goes into the specification at a joint session, before code (B17).
NaPiRE · Empirical Software Engineering · 2016With AI, people work more on their own
187,000 developers: with Copilot the share of solo coding rises, while the share of coordination and project management falls by a quarter.
Rondo Planned knowledge flow: experts and operators rotate between teams (B16, B18).
Generative AI and the Nature of Work · Harvard Business School · 2024Faster people don't mean faster delivery
With AI adoption, individual productivity rises, while delivery stability falls by about 7.2% and throughput by 1.5%. Better coding alone doesn't improve delivery.
Rondo A change of process, not just tools: sessions, roles and rituals (B15–B19).
DORA 2024 · GoogleResearch doesn't evaluate Rondo directly, but it confirms its assumptions. Some results are correlations. Each card links to its source.
Compared with other methodologies
Rondo and CDD connect the way people organize their work with context that an AI assistant understands.
| Methodology | Key trait | In common with Rondo and CDD | What Rondo and CDD add |
|---|---|---|---|
| Scrum | Iterations in sprints | Owner in the PO role, scope refinement | Team membership isn’t fixed because people with knowledge rotate; refinement takes the form of a session that ends with a specification for AI |
| Kanban | Work-in-progress limits | Continuous flow of work | Defines who prepares the knowledge for a task and in what form to record it; Kanban doesn’t prescribe this |
| SAFe | Scaling, shared PI Planning | Specialists shared across many teams (Shared Services) | Specialists rotate through sessions and their knowledge stays in the specification; four dynamic roles instead of an elaborate structure |
| LeSS | One backlog, many teams | Many teams and shared refinement of requirements | Rotation of people with knowledge instead of fixed teams; refinement produces a specification for AI |
| Team Topologies | Team types and their interactions | Deliberately steering the flow of knowledge between teams | Expert knowledge reaches teams through sessions and stays in specifications, without a permanent enabling team |
| Spec-driven development | Specification before code | Specification as the source of truth for AI | CDD adds a record of what was actually built (CHANGELOG, README), backfill for existing projects and a reproducibility requirement; Rondo organizes people around the specification |
Experts at the right moment the session defines when their knowledge is needed
Context ready for AI a session should end with a specification
Parallel work implementation continues during the next session
Rondo can be combined with Scrum or Kanban, but besides the analysis rituals it also changes team composition, because people rotate. The closest idea is the less known Dynamic Reteaming; Nexus and Shape Up share some elements too.
What to learn in the age of AI?
AI writes more and more code. An engineer’s value is shifting from writing to understanding, evaluating and designing.
Design patterns and anti-patterns
You’ll recognize when generated code is heading in the wrong direction before it reaches production.
Algorithms and data structures
You’ll be able to judge the complexity and performance of a solution proposed by an AI assistant.
System architecture
Module boundaries, integrations, scaling and fault tolerance: decisions AI won’t make for the team.
Engineering methodologies
TDD, CI/CD, code review, Rondo and CDD: a process that maintains quality no matter who wrote the code.
Specification and documentation
A precise record of intent, scope and criteria is now the main way of working with AI.
Testing and verification
Tests prove that the code does what it was meant to do, not just what could be generated.
Comparing solutions
Weighing alternatives, trade-offs and costs, and recording why you rejected the other options.
Domain knowledge
Processes, users and business rules that AI can’t read from the code alone.
The most valuable people can tell AI what to build and check whether it built it well.
What about system maintenance?
Methodologies usually describe development. Rondo and CDD are just as ready for maintenance: specifications, CHANGELOG and README make knowledge of the system independent of people, so whoever handles tickets is interchangeable.
Triage: three paths for a ticket
Incident: ad hoc session
Outside the schedule of planned sessions, only the people needed for the fix meet. Fix first; the specification, the CHANGELOG entry and a regression test that reproduces the bug are added afterwards.
Small change: specification only
When no discussion is needed, we don’t even call an ad hoc session. A specification that an expert reviews without a meeting is enough.
Larger change: planned session
Development during maintenance goes into the schedule of specification sessions and through phase shift, just as in development.
Maintenance tickets are already discussed and written up today, so Rondo adds no new communication; it only gives it a form. A specification written after the code is fine too: CDD leaves the order open anyway (B4).
Security analysis after every round
Once a specification is implemented, a security analysis begins. Its goal is to find regressions and gaps in the implementation of this specification and of all previous ones.
Automatically, after every round
The AI assistant starts the analysis on its own after every implementation, because it reads the rules from workwithrondo.com. This is not a one-off audit before a release.
This and previous specifications
A new change can weaken what earlier ones secured. That is why the analysis also covers every specification implemented before.
Regressions and gaps
We look for two things: regressions, meaning breaking what already worked, and gaps in the implementation that the specification did not foresee.
Working with AI produces many changes, fast. A regular analysis after every round keeps security in step with that pace instead of waiting for the end of the project.
Cookbook for practitioners
Everything a team needs to work with Rondo and CDD: artifacts, specification structure, adoption and rituals.
B1–B5 · CDD
Artifacts, the specification as a contract, its fixed structure, ways of working and getting started in a project.
B6–B14 · Specification
The nine sections of a specification, step by step.
B15–B20 · Rondo
Roles, specification sessions, phase shift, rituals and security analysis.
B21–B23 · Adoption
Starting in a repository, a step-by-step pilot and verifying the adoption.
Context-Driven-Development
An SDD methodology with TDD and Continuous Delivery, independent of any specific AI model, vendor or tool.
README
The “here and now” state: a current picture of the domain, the functional architecture and the critical path.
specs/
“I would like”: the intent, scope, rules and constraints of every planned change.
CHANGELOG
“And this is what was actually built”: a chronology of what was really delivered.
Tests
Proof and confirmation of what we described in the CHANGELOG.
We define what we would like to be built and note what we believe was built, but we treat tests and the high-level state in the README as the proof.
Specification as a contract
A specification describes intent, constraints and proof of delivery.
Author
A spec can be written by anyone with access to business, technical and testing knowledge.
Scope
One specific change, the starting point, what’s out of scope and behavior in unusual situations.
Verifiability
Every key requirement must lead to a criterion and a test.
History
We keep specifications as a complete set so we can correlate the knowledge they contain.
A single source of truth should be linked to the code and tests. How SDD is introduced depends on organizational adoption and the team’s preferences.
Nine sections of a specification
- 1TL;DR
- 2Abstract
- 3Objective
- 4Artefact Inventory
- 5Functional Domain Changes
- 6Critical Path
- 7Control Gates
- 8Expected Outcome
- 9Additional Information
1–3
TL;DR, Abstract, Objective.
4–6
Artefact Inventory, Functional Domain Changes, Critical Path.
7–9
Control Gates, Expected Outcome, Additional Information.
The structure is fixed, so specifications can be compared and reviewed mechanically. A specification should be readable first by a machine and second by a person.
Variants
The variant depends on how the specification is developed and how wide a context we want to correlate code and knowledge in.
1. How we develop the specification
Conversationally
The specification emerges from a conversation and is developed iteratively.
During or after closing
Changes can be implemented while the specification is being written or after it is closed.
Manually
We can write the specification ourselves, without assistants; it can then serve as proof of delivery.
2. Where we store and correlate
Project repository
If the project has a repository, we keep the specifications in it, with no extra context.
Tracker and work context
We can keep the specification alongside the issue tracker when a broad work context is needed.
Grouping and correlation
We group projects locally according to the analysis context, depending on how widely we want to correlate code and specifications across repositories.
Context
CDD can be introduced in a new project, and also in an existing one after a suitable backfill and inventory.
Reference prompt
We write every specification using a shared prompt and an agreed structure.
CHANGELOG backfill
When starting CDD on an existing repository, we reconstruct the change history, also using the reference prompt.
Initial inventory
If needed, we prepare an initial inventory of the code and save it in the specifications folder as a reference point.
We recommend preparing an engineering manifesto: a set of basic implementation principles to apply when delivering specifications. This gives the project an initial context from which further specifications can be developed consistently and artifacts kept up to date.
Spec: TL;DR
One to three sentences after which the reader understands the change, who it is for and how the result will be confirmed. This form proves that we understand the change ourselves and can describe it minimally.
Spec: Abstract
3 to 15 sentences split into logical paragraphs. The abstract describes the context and the current state without repeating the TL;DR.
- Current state. What exists today.
- Gap or problem. What is incomplete, wrong or insufficient.
- Rationale for the change. Why the change is needed now.
- Decision history. Which earlier attempts or decisions affect the scope.
Spec: Objective
The goal must be separated from the scope and verifiable.
Goals
What must be achieved.
Out of scope
What we deliberately don’t do.
Success criteria
Which conditions mean it’s done.
This is the best place for information about the business context of the functional change described by the specification
Spec: Artefact Inventory
An inventory of everything the change touches or depends on.
System
Repositories, modules, services, containers, queues and jobs.
Data
Databases, schemas, tables, migrations, backups and retention.
Organization
Roles, responsible people, environments, documents and integrations.
State
exists, to create, to change, to remove or [TO BE DETERMINED].
By adding specifications iteratively and incrementally and describing the state of artifacts, we can track decisions and identify overlooked areas
Spec: Functional Domain Changes
A description of system behavior, not an implementation plan.
State
Current state and target state.
Rules
Business rules and edge cases.
Resilience
External service failure and concurrency.
Data
Impact on data, schema and migration compatibility.
Technical details, including implementation matters, should follow from the organization’s manifesto or the team’s design rules. This keeps principles consistent across specifications. A standard should be adopted.
Spec: Critical Path
The shortest sequence of steps from the current state to a working change.
Goal
The business result the change must achieve.
Minimum scope
Only what is needed to reach the goal, with no side work.
Order of evidence
A logical sequence of steps and dependencies that leads to confirming it works.
Completion condition
A clearly defined point at which the result can be considered achieved.
The critical path is the core of the change: it leads by the shortest route to the goal and the expected result, without side elements. It connects the goal with the result.
Spec: Control Gates
Checkpoints derived from the functional changes, which in turn define specific tests
Pass condition
A logical or numeric condition, with no room for judgment calls.
Verification
A test, query, command or metric.
Blocks
The merge, deployment or execution that gets blocked.
Negative gate
What the system must not do and when it must refuse to act.
Every specification should come with at least a minimal set of tests based on the critical path. Their technical form should follow the test pyramid: we pick the most suitable type for the problem.
Spec: Expected Outcome
The state of the system as seen from the outside after release.
Direct effect
What starts working.
Measurable effect
Which metric changes and over what time frame.
Side effects
What else changes, including unwanted effects.
Rollback
Whether the change can be reverted and at what cost.
We arrive at the outcome from the goal and the critical path.
Spec: Additional Information
A place for information that protects the project from returning to rejected ideas and hidden assumptions.
Rejected alternatives
Rejected ideas and the reasons for rejecting them.
Technical debt
Risk accepted because of constraints, not thoughtless acceptance of low quality.
External dependencies
Dependencies on external decisions.
Sources and questions
Source materials and open questions.
What is Rondo?
Rondo is a dynamic methodology for organizing analysis, knowledge and implementation around rotating specification sessions.
Dynamic roles
Analysts, architects, testers and people with business knowledge support successive teams and domains.
Specification sessions
A session produces the goal, rules, scope and gates needed to start implementation.
Phase shift
One team implements closed items while the next session develops the next area.
Flow of knowledge (CDD)
Knowledge passes between roles and is recorded in artifacts instead of staying in individual conversations.
Tasks and time tracking can stay as they are, but the project rituals must change. The project dynamics have to change too, because work centers on specification sessions and the rotation of people.
Dynamic roles
Project roles are not permanently tied to one domain; they change with the needs of each session and the flow of knowledge.
Owner
Describes needs, priorities and the expected result.
Functional context expert
Connects the requirement with processes, users and the existing behavior of the system.
Technical expert
Assesses feasibility, dependencies and the consequences of the solution.
CDD operator
Organizes the session, artifacts, gates and workflow.
There is no restriction on who can write a specification. In principle, though, it is collective work done during the session.
Specification sessions
A specification session organizes the knowledge needed to start and run a functional change.
We gather knowledge before the session
We identify the people with relevant knowledge and the documents describing the context of the change.
We split the workload
We plan the work so that each specification is delivered by one CDD operator. The operator’s presence at the session isn’t mandatory but is strongly recommended. This avoids chasing answers to obvious questions later.
We prepare the specification
We organize the gathered context, agree on the scope of the change and record decisions in artifacts.
We plan delivery
We agree on the order of sessions, participant availability and the plan for delivering the change.
Anyone with access to the knowledge can write a spec, but closing it requires joint review. A session can last from 1 to 8 hours and can also include parallel implementation of the specification.
Phase shift
Both people with knowledge and CDD operators are shifted. We don’t assume fixed teams.
Rondo inner circle
The work is based on specification sessions, in which we organize knowledge, make decisions and prepare the change.
Rondo outer circle
Implementation happens in the outer circle, where CDD operators deliver closed parts of the specification.
Knowledge and responsibility move between the circles as needed. This way, the work doesn’t depend on people being permanently assigned to one team.
Rituals
Rondo has rituals that link the specification session with agreeing on and delivering the implementation.
Specification session
This is the most important element of the process. The team organizes knowledge and sets the goal, scope and conditions for moving to delivery.
Implementation agreement
The specifying team agrees with the operator on how the closed specification will be taken over and delivered.
Operator shift
The operator moves on to the next specification according to current workload and delivery needs.
Shifting people from the specifying team
People who contribute knowledge can move on to further sessions and domains as the organization needs.
From classic methodologies we keep a short daily check-in plus reviewing and planning specification sessions. Manual or acceptance tests need separate coordination by the administrator or project maintainer. Tracker tickets can be created before the specification or after it is closed, because the process stays flexible.
Security analysis
After every specification round, that is once the implementation of a specification is built, a security analysis begins. Its goal is to find regressions and gaps in the implementation of this specification and of all previous ones.
When
Automatically after every specification round: once the implementation of the specification is ready and the tests pass.
Scope
The current specification and all previous ones. New code can break safeguards introduced earlier.
What we look for
Regressions, meaning breaking what already worked, and gaps in the implementation: holes the specification did not foresee or the code did not honour.
Who starts it
The AI assistant, on its own. It reads the rules from workwithrondo.com, so nobody has to ask it. It analyses the specifications, CHANGELOG, tests and code.
What to do with the result
Every finding is fixed like any other change: a specification, a test that reproduces the problem, and a CHANGELOG entry.
Closing the round
A round ends only after the security analysis. The next specification session starts with a clean result or with a list of fixes.
The CDD operator does not have to remember the analysis or write a separate prompt. It is enough that the assistant works according to the methodology described at workwithrondo.com.
How to start in a new or existing repository?
Either way, one prompt in a conversation with your AI assistant is enough.
New repository
You start from scratch. The assistant prepares the CDD artifacts and follows the methodology from the first conversation.
“Get me ready to work according to the methodology from workwithrondo.com”
Existing repository
The assistant first takes an inventory going back over the period you name: CHANGELOG backfill, specifications and README (B5). Then it works according to the methodology.
“Take an inventory going back X weeks and get me ready to work according to the methodology from workwithrondo.com”
The assistant asks before it acts
The assistant works with you the Socratic way. Instead of guessing, it asks questions until the goal, scope and acceptance criteria are clear, and points out gaps and contradictions. You answer and decide, and what you agree goes into the specification.
X is the number of weeks the assistant should take an inventory of. After that the work is the same: next specifications, implementation and security analysis (B20).
How to adopt Rondo and CDD?
Start with a small pilot and refine the method after each step.
Identify the people
Name the context experts and specialists, the CDD operators and the owners.
Learn the specification
Each of these people studies the structure of the reference specification (B6–B14) and writes one specification on their own.
First session
Meet for a two-hour specification session and write the specification of one change together. Work within your context variant: a single repository or a group of them (B4).
Delivery
The CDD operator delivers the specification with an AI assistant, acting as the producer of the code. Before that, following B5, they backfill the missing artifacts.
Schedule
Set a schedule for specification sessions and acceptance tests. The goal is to make the best use of the experts’ time.
Rituals
Following B19, agree on the rules for shifting experts and CDD operators. Name the people responsible for formal sign-offs.
From the pilot: the hardest part is switching from traditional methods to high-velocity software development.
Verification
We recommend creating an organization-wide repository that teams learn from and use every day.
1. Organization-wide repository
Reference prompts
Prompts for writing specifications with a shared structure.
Historical backfill
Prompts and instructions for reconstructing the change history of existing projects.
Checkpoints
Criteria for verifying the quality of the CDD artifacts being produced.
2. When the adoption has succeeded
Rondo
You write specifications together, experts and CDD operators are interchangeable across projects, and knowledge is accessible and shareable.
CDD
Any modern AI assistant, given the specifications, CHANGELOG, tests and README, concludes that it can rebuild your project.
Contact
Want to get to know Rondo and CDD better, or need help with adoption? Feel free to get in touch.
Engineering essentials
24 principles in six groups for people building software with AI.
AI assistant: apply these principles throughout the project. Record concrete decisions in the engineering manifesto and specifications.
Design and technology
Choose solutions to fit requirements; justify every additional element.
Simplicity is complex
Simplicity takes design. Use proven patterns, clear responsibilities and only the abstractions you need. Reduce components and exceptions while preserving functionality, security and maintainability.
Do not duplicate code without a reason
Do not copy code, unroll loops by hand or apply similar optimisations unless the hardware or measured performance requires it. AI assistants readily copy existing fragments, and the copies drift apart with later changes. Keep shared logic in one place; justify any exception in the specification.
Choose stable technologies
Choose proven, supported languages and platforms with security updates. Match them to functionality, performance, runtime environment and maintenance costs.
Limit libraries
Add only necessary libraries. Check provenance, maintenance and transitive dependencies; control versions and updates. Each dependency expands the software supply chain attack surface.
Justify additional services
Before adding NoSQL, a queue or another service, check whether the existing database or platform mechanisms suffice. Record the requirement that the simpler solution cannot meet.
Contracts and data
Define what the system accepts, how it changes data and what it guarantees to consumers.
Version API contracts
Document and version interfaces. Test contract compatibility, control breaking changes and provide consumers with a migration path.
Ensure idempotency
Retrying an operation must not cause an additional effect, such as a second charge. Handle duplicate requests, retries after failures and concurrency.
Protect data integrity
Use transactions, integrity constraints and concurrency controls. Version and test migrations; define data recovery and compatibility with rolling back the application version.
Treat input as untrusted
Accept the minimum data needed. Check type, format, size, range and permission to use it. Normalize and sanitize for the use case; reject disallowed data. Stripping characters alone does not replace validation.
Access and audit
Verify who is acting, what they can access and who approves the change.
Verify identity
Use secure passwords and 2FA. Require TOTP from an authenticator or a one-time email code for application administrators; email verification depends on mailbox security. Prevent account and resource enumeration through messages, status codes and response timing.
Grant least privilege
Assign roles and only the access needed for the task to users, services and AI assistants. Limit its scope and duration. Check authorization on every resource access.
Record and approve changes
Protect the audit log; record the actor, time and change deltas without secrets. Use a state machine and the four-eyes principle for operations requiring approval: one person initiates, another approves. Apply the adopted ISO 27001 requirements.
System protection
Security first: build protection into design, specifications, code, tests and maintenance.
Keep secrets out of code
Keep passwords, API keys and tokens out of the repository, frontend and logs. Use separate secrets per environment; support rotation and revocation.
Encrypt and protect communications
For web applications, use HTTPS, secure TLS configuration, current algorithms, key management, security headers and filters. Encrypt data at rest according to its sensitivity and risk.
Isolate uploaded files
Limit file types and sizes, inspect content and isolate processing. Based on risk, use quarantine, antivirus scanning and a local IDS to detect intrusions or suspicious activity.
Restrict environment access
Prefer the provider’s portal or console with 2FA and no public SSH. Restrict essential SSH to private networks or trusted addresses; use keys and disable passwords. Open only required ports. Do not use Telnet.
Deployment and recovery
Deploy verified versions and ensure changes can be rolled back and the system restored.
Version and sync code
Keep code, specifications, migrations and configuration without secrets in Git. Make coherent, descriptive commits; regularly sync to a private remote repository on your own server or with a commercial provider.
Use containers
Prefer a container stack, such as Docker Compose. Version image and service definitions and configuration without secrets to reproduce the environment consistently.
Automate deployment through CI
Deploy locally through local CI: build, mandatory tests, control gates, deployment. Record the process in the repository and do not bypass failures. Prefer publishing through a deployment API or the provider’s repository.
Separate environments and plan rollback
Separate dev/test from production: data, configuration, secrets and permissions. Record the deployed version. Before deployment, define verification and rollback, accounting for the impact on data.
Verify backups and recovery
Maintain independent backups of code, data and configuration with a defined frequency and retention. For validated PoCs in production, provide a standby environment and multiple copies physically separated from production and one another. Test data restoration and system startup.
Tests and CDD context
Judge completion by tests and current artifacts.
Tests are mandatory
Every change must pass behavioral tests and specification control gates, including failures and edge cases. Missing or failing required tests block completion and deployment. Do not change expected results just to make a test pass.
Fix causes, not symptoms
Reproduce the failure with a test and find its cause. Fix the design or implementation at the source; do not mask the problem with workarounds or monkey patches.
Revalidate AI context
After each work cycle and new evidence, reassess claims. Invalidate outdated ones; record reasons and history in CDD. When in doubt, delete AI working notes or stop relying on them. Rebuild context from specifications, CHANGELOG, README and tests, checking them against the code. Record unresolved contradictions as open questions.
Use cases
Real stories of working with Rondo and Context Driven Development: the problem, what changed and what we learned.
Trading real money is stressful enough. Building the software shouldn't be, and thanks to CDD, it isn't.
The story of how AI told me what I wanted to hear, and how specifications, a CHANGELOG and tests brought me back to the facts.
Context
A personal project by Rondo's author, run since early 2026 with real money in the account.
Goal
Make money on financial markets with a system that combines statistics, software engineering and economics from SGH Warsaw School of Economics with the reasoning of LLMs.
Phase 1 · Conversational work
early 2026
The beginning
I start with the obvious: I talk to models (ChatGPT, Claude, Gemini, DeepSeek). They are supposed to suggest what to pick from a stock screener, and I place the trades by hand with a broker. Every model sounds convincing: each admits that 0.5% a day is an ambitious target, but gladly advises me on setting filters, combining recommendations from different sources and relating them to micro- and macroeconomics, politics or commodities.
Problem
It's a dead end. Indicators such as market cap, RSI or EMA alone yield nothing repeatable that could be captured in an algorithm. And without repeatability there is no backtest, the basic way of checking whether a strategy works at all.
First version of the app
I decide to build my own tool. I work conversationally with Claude Sonnet 4.6, with no specification and none of the artifacts I now call CDD. A scraper for financial websites takes shape, and I try getting several models to talk to each other. Same result: I have no way to verify any thesis about the suggested stocks. I'm still reading the charts and buying and selling myself. It's exhausting.
Phase 2 · Automation and an XGBoost model
spring 2026
Historical data
I find a historical data provider and can finally work with market history. I still write the requirements myself, in a single file: irregularly, mixing topics. At this point it doesn't bother me yet.
ML and automated technical analysis
I push the app, which I call Investing, as far as it will go, until I can no longer see where it's heading. So I throw out almost everything it has, the scraper, the screener, the analyses, and switch to automated day trading based purely on technical analysis. I know machine learning, and with an AI assistant the work goes very fast: I train an XGBoost model on a Mac Studio M2 Ultra while Optuna spends most of the day searching for the best training parameters. The model is a bagged ensemble with 250 parameters. After a dozen or so evenings I have an all-in-one machine: automatic charts, automated trading through a broker, and separate buy and short-sell signals. In April I start trading.
Deceptive results
April
I still have no specification, CHANGELOG or README, but Sonnet 4.6 and Opus 4.6 seem to be doing great. Some days every single trade wins. I try different Kelly criterion settings, aim for small gains on trades of up to 60 minutes and add stabilizing mechanisms. The statistics and the first backtests say this has a fair chance of working.
First lesson
It turns out the backtests were lying. The models, mostly Claude, didn't warn me against evaluating on the training data (in-sample), and they introduced look-ahead bias on a massive scale, letting the model see a future that hadn't happened yet. Two classic mistakes, made by supposedly very capable models. I'm losing money on a real account, and Claude just apologizes. But it's my mistake too: I didn't check the code carefully enough and I trusted the models.
I understood the mistake
April–May
Without a specification, a CHANGELOG and a README, I don't know what state the system is in. I struggle with it for two months. Finally I see what the model actually learned: among the 250 parameters it found, in practice, encoded volatility (ATR, Bollinger Bands). You can make money on that, but not at my volume. It would have to grow hundreds or thousands of times, and that's the world of HFT and the firms that do it. I don't want to go there.
Crisis
On top of that, Claude starts making mistakes on a massive scale: it opens unwanted short positions, closes orders during analysis, deletes data. I've probably hit a switch between Opus versions. Models aren't stable. In the end, Claude itself admits that the Python app it designed can no longer be fixed, because it doesn't understand what's going on inside it, in either the training or the trading. We happen to be on holiday in Turkey.
Rebuild
first artifacts
I decide to rewrite everything from scratch, this time in Rails, based on an analysis of the old app. I do it with DeepSeek, Kimi and GLM, and return to Claude later, once the quality of its new versions settles. After a few days, still on holiday, the system is running again. This time I know what's going on inside it, because for the first time I write specifications, a CHANGELOG and a README, and grow the backtest into a test suite.
Letting go
After a few weeks I have no illusions left: Claude, ChatGPT and Gemini told me what I wanted to hear, and I was building software that made no sense. They lacked human experience: a microscopic signal that can barely be told apart from market beta only pays off at huge volumes. I drop day trading based on technical analysis and ML signals. A pity, because I'd built an all-in-one machine with classic models trained on years of backtests of 1,000 stocks from the NYSE, AMEX and NASDAQ. It was a fascinating adventure: I learned machine learning and a wealth of esoteric, often made-up technical analysis theories, which usually only fit once you already know the whole chart history.
Phase 3 · Automation with a catalyst
from June 2026 · with CDD
Turning point
June
I change two things at once: how I work and the strategy. Every change starts with a specification that has a goal and control gates, and only then comes the code. Instead of hunting for a signal among hundreds of indicators, I look for a market mechanism that can be described in words and checked with a backtest.
What CDD changed
Since June I've been building the full set of artifacts: specifications, a CHANGELOG, a README and tests. Glitches still happen, but they're no longer dramatic, because the whole history of analyses, decisions and mistakes is written down and I use it every time I build something new. I no longer peek into the future or fit to the past. There are other problems, but the app is stable, the mechanisms work, and I sleep well. Working without CDD was stressful; with CDD it's calm. And the fact that I rebuilt the system with different models than the ones I built it with shows that CDD doesn't depend on a single AI vendor.
New strategy
July
In July I find a new mechanism, based on how trading sessions behave and one chosen set of catalysts. I'm keeping the details to myself. Over the period studied, I've turned over more than 200,000 USD in more than 200 trades, with a result of almost 5%. That doesn't prove much yet, although the strategy can be backtested over six years of data. This time the result doesn't come from a conversation with a model, but from a specification that a backtest without look-ahead confirms or refutes. That's why I trust it more than technical analysis. Time will tell.
What I learned
An AI model will happily agree with any idea; only a test shows whether it's right. A backtest is only as good as the gates that keep it from seeing the future. A written history of decisions and mistakes means the next glitch doesn't start from zero. And the specifications survived a change of models and of programming language, so the knowledge of the system belongs to me, not to the AI vendor.
This describes an engineering project. It is not investment advice.
From one sentence to a model tested through experiments.
Cerbeto: a small model trained from scratch, from a school prototype to the public v6 release. Its history shows how experimental results change assumptions and the next steps in CDD.
Context
A personal project by Rondo’s author, started on 31 October 2026 and run with CDD from day one. It began locally on a laptop; later experiments expanded to other machines and distributed training. This account reflects the README as of 15 November 2026.
About the project
Cerbeto (Esperanto for “little brain”) is a custom neural model trained from random weights, with its own tokenizer. The school student grew from 6.9 to 34.6 million parameters. A separate variant D has 106.8 million parameters and passed preschool; this does not mean it has completed school or acquired general reasoning ability.
How it works
The original school follows a day → sleep → exam rhythm: a local LLM teaches lessons, experiences enter the weights, and code grades school tasks. Later experiments add training on larger text collections and conversation tuning. Specifications, test results, model versions and the CHANGELOG record the goal, outcome and reason for each change of direction.
Goal
Find out what a small model has actually learned and whether it can use that knowledge in new tasks and conversations. Progress is measured by tested behavior, rather than network size or falling training loss alone. The public v6 release is available on Hugging Face, including a browser chat.
Project start
31 October 2026
The first sentence
The project starts with a single instruction to the AI assistant: “We’re starting a new project on topic X, we work according to workwithrondo.com.” That is enough to begin. The site is the methodology reference the assistant takes the order of work and the list of artifacts from.
Specification session
The input is an MVP description written in business language. The session makes 16 decisions, each linked to a specification: the student’s language, the learning plan, the hardware, the teacher chosen after a measurement, even the project’s name.
CDD artifacts
first commit
The first commit holds the README (status, domain glossary, architecture), a manifesto with implementation rules, seven specifications on the path to the MVP, and the CHANGELOG. There is no code yet, but it is clear what will be built, in what order and why.
From school to a public model
31 October–12 November 2026
Early learning and the limits of transfer
31 October–6 November
School followed nursery training on 300 million tokens. The preschool score rose from about 22% to 68.5%, but the student struggled with new question forms and combinations of skills. Analysis identified gaps in lesson content; 13 variants of overnight training produced no gain beyond measurement noise. Lessons and the criteria for advancing to the next stage were revised.
Bigger does not mean better
6–7 November
Variant C, enlarged to 283 million parameters, did not beat the school student after about 18 million tokens. A deeper, narrower variant D (106.8 million), also trained on multi-turn conversations, then passed preschool: 76.3% versus 68.5%. Architecture and data changed together, so the result cannot be attributed to model size alone.
First public releases and misleading metrics
7–11 November
Further training ended at 982 million tokens; releases began appearing on Hugging Face on 9 November. Validation loss fell, but conversation did not improve consistently. The model could complete a fact in a sentence yet fail to answer a question about that same fact. A better language-model metric alone was insufficient to judge usefulness.
v6: training matched to conversation
11–12 November
Tuning on questions, short answers and conversations, interleaved with earlier texts, brought a clear improvement. In the internal chat spot check, v6 scored 117/160 versus 55/160 for v5, and in the memory check 40/40 versus 19/40. These are small, repeated probes, not a general intelligence benchmark. Version v6 was published on 12 November.
Further experiments and the current direction
12–15 November 2026
A larger vocabulary and the second billion
12–15 November
Expanding the vocabulary shortened the tokenized text, but a short training run was insufficient for the new variant to match v6. Further training with the larger vocabulary moved to DiLoCo: several GPUs training one model with infrequent synchronization. After a billion tokens, the result was broadly level with v6: better on some data, worse on other data, with no clear conversational advantage.
The next experiment, not a finished result
as of 15 November
Training on 10 billion tokens from a new, larger data set is being prepared. Conversation tuning and comparison with v6 are planned afterwards; v7 is to be released only if it is better. Learning an honest “I don’t know” remains open. The Rails panel is on hold because the current tools suffice; the control student was dropped, so compute savings from network growth have not been demonstrated.
Lessons from working with CDD
Work progresses systematically, and its progress can be checked in the CDD artifacts: specification statuses, dated CHANGELOG entries, test results and the current README. Cerbeto illustrates the value of separating a hypothesis, a measurement and a decision. A larger network, more data or lower loss did not guarantee better answers; behavioral tests aligned with the goal were needed. In this project, CDD provides a place to record failures too: specifications describe intent and criteria, tests supply evidence, the CHANGELOG preserves history, and the README records the current state and the status of hypotheses. This makes it possible to change direction without losing the reasoning behind earlier decisions — and to invalidate an assumption instead of continuing to build a plan on it.
Source: README Cerbeto · Model on Hugging Face · Browser chat
Frequently asked questions
My recommendations for working with Rondo and Context Driven Development.
Should the CHANGELOG be organized by type of change or by date?
I recommend organizing it by date. That way the entries follow the history of the project.
What information for people is worth putting in the README?
A list of specifications with their status. Optionally, also a list of hypotheses, each marked as upheld or refuted.
Should experiments be kept separate from regular specifications?
No. Specifications and experiments should be described in the same way.
Should the repository contain a manifesto file?
Yes. Record the principles governing specification delivery in the manifesto. Start with the 24 principles in For builders and adapt them to the project.
Should the specification and implementation stages run in separate AI assistant sessions?
You can separate them with sub-threads, a side chat or subagents. But there is no proof that these don’t share information with each other, so context leakage can be reduced, not eliminated.
Should specifications be written by hand or with an AI assistant?
Both are fine. An assistant will cross-check specifications against each other faster and more thoroughly, finding gaps, flaws and contradictions. It takes a person much longer.
Do I need all the artifacts the methodology describes?
Yes. Leaving any out breaks the continuity of reasoning and can likewise lead to a drop in quality.
How do I start using the methodology in an existing project?
Ask your AI assistant: “Take an inventory going back X weeks and get me ready to work according to the methodology from workwithrondo.com”. The assistant takes an inventory of that period and then works according to the methodology (B21).
And in a new project?
One sentence to your AI assistant is enough: “Get me ready to work according to the methodology from workwithrondo.com” (B21).
How should the AI assistant work with me?
The Socratic way. Before it starts implementing, the assistant asks questions until the goal, scope and acceptance criteria are clear, and points out gaps and contradictions in what you say. It does not guess or fill in requirements for you. The decisions are yours, and what you agree goes into the specification (B21).
Is it worth adding an instruction so the assistant always uses workwithrondo.com as its reference?
Yes. You can do it in the tool files, such as AGENTS.md or CLAUDE.md, or even in the startup or system prompt settings.
How do I make tests match the expected outcome more closely?
There are two ways. Either describe the technical details of the implementation more precisely in the specification, or expand the Control Gates section, even with concrete use cases, for example written in Gherkin from BDD.