Product code
The agent that can change and verify the IDE implementation.
example · ultimateJetBrains · Agent workflow
Give agents structure.
Let them work.
Stay in the loop.
A practical example of how I coordinate agent work across codebases without managing every message myself.
The three parts
01Shared knowledgeContext and instructions live with the work.
02Specialized agentsEach task runs in the environment that owns it.
03One visible interfaceBB and HTML briefs keep progress and decisions clear.
jetbrains-skills/ — one example
•◆agent-instructions.md
›▰workflows/
◆research · build · evaluate
›▰current-state/
›▰evidence/
›▰decisions/
›▰deliverables/
Concept 01 · Shared knowledge
Markdown gives agents a place to begin.
jetbrains-skills is one example: instructions, state, evidence, and decisions live together in a structure agents can navigate.
01Instructions are explicitThe agent reads how the work should be done instead of reconstructing it from chat history.
02State survives sessionsNew agents inherit what is current, what was tried, and what remains undecided.
03Evidence stays attachedResults can be traced back to the work that produced them.
Concept 02 · Specialized agents
The coordinating agent knows where work belongs.
The knowledge base documents ownership. The first agent can start a focused agent in the right repository with the context, constraints, and expected result already attached.
A
Coordinating agent
Understands the goal, current state, repository map, and definition of done.
task → improve an IDE skill
route → the repository that owns each step
send → focused instructions
return → verified result
route → the repository that owns each step
send → focused instructions
return → verified result
→
Evaluation tasks
The agent that owns scenarios, test projects, and verifiers.
example · harbor-datasetsLocal evaluation
The agent with the harness, sandboxes, and run tooling.
example · harbor-frameworkCloud evaluation
The agent that runs larger matrices and returns the results.
example · ai-assistant-pipelinesOne example · php-runtime-tools
From a repeated mistake to measured improvement.
Agents could use the wrong PHP interpreter and still return a plausible answer. The system coordinated the skill, the product change, and the evaluation.
1
Define the problem
Use the PHP interpreter configured for the project—not whichever binary appears first.
2
Send work to the owners
Product and evaluation agents each handled the part their repository owns.
3
Bring back evidence
The knowledge base connected the change to a repeatable with-skill / without-skill comparison.
Why this is a useful example: one coordinating context produced code, evaluation work, results, and a decision without one agent pretending to own every system.
1.8→90.2%correct
−53%cost per trial
−66%time per trial
Concept 03 · BB IDE
Threads make the agent system visible.
Each repository has its own environment and agent context. I can see active work, inspect a thread, and keep parallel tasks attached to the right project.
✣Improve an IDE skill
Coordinate the implementation and evaluation, then return the result and any decisions I need to make.
Reading the shared context
Routing product work
Running the comparison
Updating the result
◉Live brief
The work is complete
The implementation and evaluation are linked. One decision needs your ruling.
What should happen next?
Use the result
Run another comparison
Concept 04 · Human interface
The page is the conversation.
I do not have to follow every chat thread. Agents publish one live HTML brief with what changed, what is blocked, and what decision is mine.
1Start new workA button can open the right BB thread with the context already attached.
2Receive updatesThe agent rewrites the page as the work changes.
3Answer in placeMy choice becomes the agent’s next message and closes the loop.
https://…getbb.app/bb/project/thread/brief.html
Agent workstream
The task is complete. One decision is needed before work continues.
NEEDS YOUWhich direction should we take?
The agent has compared the supported options and shown what each changes.
Review the decision
START WORKLaunch the next task
The project, context, and constraints are already attached.
Start a new agent
Bonus · This presentation too
I brief the agent like a product designer.
The output is a working web artifact, not a document pasted into slides.
1One standalone HTML pageNo framework, CDN, or build step at view time.
2Minimal words, visual structureUse diagrams, UI mockups, and web-product composition.
3No-scroll slidesArrow navigation, fixed canvas, and visual checks at the target screen size.
4Concrete referencesPoint to screenshots, codebases, facts, and the exact story the deck must tell.
✣Direct instructions to the agent
Build a standalone presentation.Keep every slide concise and visual.
Use a web-page product aesthetic, not a conventional slide template.
Use the supplied interface screenshot where it helps, but change the content to tell my story.
Include arrow navigation. No scrolling. Verify at 1440×900.
I point the agent to the working repository, screenshots, and facts it should use.
Finish with a live URL and an HTML feedback form.