HANDS-ON
From Code Executor to cognitive orchestrator — a transition which has already begun
You prefer the essentials first? Read synthesis (~1 min)
How many of you spend more than half the day Solving repetitive tasks... Instead of drawing architecture?
If you raised your hand — even mentally — this presentation is for you.
And if you thought the AI was going to solve this, making your day lighter — We're gonna need to talk about this too.
PRESENTATION
Developer since 2003 · On the Network since 2018 · Support for the conquest of new customers
44 years old. Married to Talita. Father of Yumi (14), Luke and Matheus (9).
Information Systems · Logistic Operations · Statistics Applied · Science of Data.
Over 22 years developing systems.
It's not just learning a new tool.
Tools change. Models evolve every day.
What doesn't change is your ability to think, judge and decide.
What needs to evolve is you.
Before the tool, three words.
The invisible skeleton that sustains all that comes after — and that the AI never replaces.
What expands you
A tool is a resource created to facilitate, improve or make possible the execution of a task. It serves to expand human’s natural abilities — whether physical or physical mental — reducing the effort needed to achieve a goal.
The calculator is humanity's first cognitive tool: instead of Spending mental energy with repetitive calculations, you outsource that effort and free your mind for what It matters. Generating AI is the cognitive calculator of the 21st century — but for thought, not for numbers.
The process under way
Defining thought is how to describe the wind: you do not see it directly, but feels its effects on all actions. In essence, thought is our interface with reality. It's the process of manipulating information to form concepts, create hypotheses, remember and decide paths. It's the that happens between the problem and the solution.
The AI sues. You think. The difference is not in speed — it is in awareness and intentionality behind each movement.
The quality of thought
If thought is activity itself, intelligence is the quality of this activity. The AI has formidable analytical intelligence — it processes data, finds patterns, generates solutions on a scale. But it fails in contextual intelligence: it does not understand what is not written, it does not realize when the premises have changed, does not feel the political pressure of a decision.
The new value of the professional is exactly in this gap: be the filter critical, the guardian of context, the judge of what the machine cannot see.
She didn't make us any more stupid. She let us go for what matters.
The human brain uses analytical thinking to process mathematical calculations sequentially and logic. But this processing takes time and metabolic energy.
The calculator outsource this mechanical effort — it processes mathematical information from instant form and returns your mind to tasks of higher cognitive level.
Generating AI is the maximum evolution of this calculator. Not just math -- cognitive. She assumes the manual work of repetitive thinking so you can focus on strategic work Do creative thinking.
The paradox no one tells: AI does not automatically make the day lighter. It eliminates the friction of tasks simple and makes the day much denser. The bottleneck is no longer the production mechanics — and became orchestration and auditing. Who doesn't evolve the way of thinking, just feels the weight Extra.
The task that needs to be solved
What reduces resolution effort (calculator → IA)
What do you do with the released mental energy?
Vibe Coding is no less typing.
Think about it.
It's to rule with the same discipline you once ruled syntax.
The client asks for a risotto to refer to an autumn night.
Nobody cares about the oven temperature. Just the experiment.
Imagine a gourmet restaurant. When a customer sits at the table and asks for a "Risato de Mushrooms that refer to an autumn night," he's making a purely abstract request — either experience, not a prescription. It doesn't dictate the temperature of the oven or the milligram of the salt.
In traditional development, the developer was the one who cut every ingredient manually: line by line. code line, server configuration, syntax exhaustion.
Today, the kitchen was hyper-automatic. Generating AI is the super-calculator of the kitchen: it stings ten kilos of onion in seconds, instantly calibrates the oven and knows the recipe of any framework of the world. The developer stopped being the kitchen worker.
But there is a silent danger: the chef who stops understanding the ingredients because the AI has always stung the onion begins to lose judgment on the dish. Speed without mastery is efficiency without direction. The risk is not The AI taking the job -- is you outsourcing the trial.
And there's something that the AI never You'll know if that client has an allergy. If the restaurant kitchen meets food safety rules. If that client's autumn night is melancholy or cozy.
That's up to you.
Brings abstract desire
Focus on the final value. It doesn't say recipe, ingredient or method. He knows what You want to feel, not how to do it.
Pick, calibrate, run
He knows all the recipes, writes any language in seconds. Yeah. fast, accurate and tireless — but execute without judgment.
Make sure the dish has a soul
It judges context, security, business rules. Takes responsibility for result. It's your name on the restaurant door when the plate goes wrong.
ACT II
But after all —
Who's Devin?
It's not a chatbot that answers questions. It's a operational agent — an enforcer oriented to objectives that use real tools to change real systems. The difference changes everything.
COMMUNICATION WITH AI · EPIC 04
Prompt engineering is not a niche technical skill — it is the new form of technical leadership. Mastering these four principles changes the quality of what you get from any agent — Devin, Copilot, Stackspot or anyone else. Think of it as the new professional fluency: who best articulates intention, gets better results. It's not magic. It's applied engineering.
Communicate as a senior professional guiding a highly capable beginner. No ambiguity, no misunderstanding. The AI works from what you He wrote and filled out the rest by inference, which could be wrong. If the instruction is vague, the result will be vague.
Clarity is not verbosity — it is precision. Every word in instruction must carry intention. Remove anything ambiguous; add everything necessary to reduce incorrect interpretations.
Not clear.
"Enhance that code."
Of course
"Refactor this method to follow the principle of sole responsibility, without altering external behavior and keeping existing tests passing."
Provide scenario, history and restrictions. The AI executes an error with the same speed running a hit — the difference lies in the context you offer.
Context includes: which system is being modified, what are the business rules relevant, which decisions have already been taken and why, and what are the limits that They can't be exceeded. The more you treat AI as a collaborator that You just entered the project, more assertive will be the result.
Practical tip: Before each significant task, pass to Devin: (1) what the system does, (2) what you are trying to change, (3) what cannot break. Three lines of context are worth ten of instruction.
Showing is more efficient than explaining. Where possible, include an example of the expected result — AI learns by default.
Instead of describing the output format, show a specific case. Set an example is the most efficient shortcut to align expectations. The AI will deduct the pattern and replicate — saving adjustment iterations.
How to apply: In asking for a report, paste an example of Well done report. When asking for refactoring, show an excerpt already refactored as reference. The example replaces a thousand words of description.
Take communication with the AI as a cycle, not as a single shot. Refine, adjust, recalibrate. No perfect prompt comes out first.
Just like no important conversation happens in a single speech, instruction and AI response is a dialogue. If the result is not ideal, analyze where the instruction failed — and try again more accurately. The problem seldom is the tool; almost always is context or clarity.
Correct position
"The result was not expected. What in my prompt caused this?"
Incorrect posture
"IA sucks."
DEVIN ANATOMY · EPIC 05
Understanding your limits and strengths is essential for effective collaboration.
Input · Visual and textual context
Devin reads files, commit history, terminal output, previous conversations. He works with what you provided — without accessing external bases or making calls from API to "search knowledge". Everything he knows comes from what's in context of the current conversation. This means that well structured context is the most variable important that you control.
Cognition · Cycle ReAct — Observe, Reason, Act, Check
Devin doesn't "find the answer" on a giant memory bank. It operates in cycles: Watch the context and current state of the system; Raciocin on better sequence of actions; Act — writes code, executes commands, modifies files; and Check the result before moving forward. This quick feedback loop allows you to fix mistakes on the way, not later. It is sequential thinking with continuous validation — the opposite of an oracle which generates unchecked response.
That's why Devin creates a PR with passing tests -- not a code response that "seems right." Each action has a verifiable consequence in the real world.
Output · Code, tests, documentation, reflection
Devin not only writes code — it also provides tests that validate behavior, documentation that explains decisions, and reflection on where you had uncertainty. You get it. not just the solution, but evidence that worked. This transparency is structural: You can audit the reasoning, not just accept the result.
What Devin Can’t — And Why It Matters
Devin is not your project manager. You don't understand deep business priorities. He is not your architect — decisions about architectural trade-offs remain yours. It's not your judge -- you can't say "in your company, the right way is X." All of it. It requires a human context that goes beyond code.
Autonomy without governance is the real risk. An agent without clear limits acts — and the consequences are Real. Define where Devin acts and where you decide is part of the work of the sovereign orchestrator.
Where Devin is excellent
Reflecting without fear of breaking — he tests everything. Exhaustive code documentation. Fast iteration without ego ("I did so, but I can do different if you prefer"). Integration with built tools and test. Accurate and systematic error analysis.
MEMORY GOVERNANCE · EPIC 05
Scene: New project, Devin doesn't know the code base.
Structure: Code walkthrough → explanation of architecture → constraints → real examples of pattern.
Result: Devin understands nuances, avoids context errors, proposes solutions aligned with existing standards.
Scene: Devin already knows the project; you have a well-defined task.
Structure: Only relevant file → specific error → criterion of success.
Result: Maximum speed, precise execution in clear scope, Token economy.
Scene: Long talk where feedback gradually refines the result.
Structure: Minimum context increment per turn → feedback from the previous result → refinement.
Result: Shared learning, token economy, progressively better quality.
Governed context allows quick and precise cycles. Feedback refine context for the next cycle — quality grows with each iteration.
Context in a conversation with the AI is like living memory — persists as long as the window Talk is open. The larger the context window (tokens available), the more history Devin can carry and use for more precise decisions.
But messy context causes hallucination — the model tries to make connections in information fragmented and incompatible. Governed context causes precision — the model understands the information structure and uses it correctly to generate aligned solutions.
Think of the context as the Briefing you give to a senior developer on the first day. If it is vague, he'll improvise. If necessary — architecture, business rules, restrictions, examples — it will deliver aligned since the first PR.
On a team scale, it evolves into what we call Context Lakes: repositories corporate knowledge structured that any agent can consume — code standards, decisions architectural, security policies, particularities of business. Knowledge Stops Living in the Head the senior developer and starts climbing for the entire team.
THE THREE ARSENALS · EPIC 06
Skills (what you know how to do), Playbooks (how you do) and Knowledge (what you do — the three axes governing all effective collaboration with AI agents. Together, they transform individual knowledge into scalable organizational intelligence. It's what separates a developer using AI from a team using AI.
What you can do — specialities where Devin performs with Your Honor, no line by line supervision.
How You Do — Reusable Collaboration Patterns. Scripts conversational for recurring work.
What you refer to — structured corporate memory. Documentation living that grows with the project.
| Skills | Playbooks | Knowledge | |
|---|---|---|---|
| Run speed | High | Medium | High |
| Output depth | High | High | Medium |
| Agent autonomy | High | Medium | Low |
| Scaleability for teams | Medium | High | High |
| Setup Complexity | Low | Medium | High |
The specialties where Devin adds maximum value.
Each skill is a domain where Devin performs with excellence, no need for line-by-line supervision.
Devin refactors code with confidence because he tests every change. Without fear of breaking, with deep understanding of the original pattern and expected behavior.
When to use
When your code still works but it's too complex to evolve safely.
Expected context
Original code + existing tests + refactor criterion (which principle to apply).
Expected result
Refactored code + passing tests + explanation of changes made.
Devin writes tests that cover edge cases you didn't think of. Test behavior, not just happy path — real coverage, not superficial.
When to use
When you need to cover extreme cases or are migrating to new architecture.
Expected context
Function/module + examples of edge cases + test pattern existing in the project.
Expected result
Comprehensive tests + cover report + analysis of identified gaps.
Devin documents not only the "what," but the "why" — decisions, trade-offs And common traps. Documentation that really helps who inherits the code.
When to use
When your code is new or needs to integrate new engineers into the project.
Expected context
Code + decision history (git log, PRs) + target audience of documentation.
Expected result
Clear documentation + use examples + links to relevant code.
Devin reads stack tracks, hypothesizes cause, proposes fix, forehead. Debug is thought sequential — Devin's strong point. Systematic diagnosis, not trial and error.
When to use
When you are stuck in obvious dead end error or root cause is not clear.
Expected context
Full error + relevant logs + code involved + steps to play.
Expected result
Accurate diagnosis + validated fix + clear root explanation cause.
Devin integrates components, workflows structure, orchestra multiple services. It follows standards and conventions — it doesn't invent architecture, it executes what you defined.
When to use
When you need to connect systems or structure a new flow between components.
Expected context
Diagrams/description of components + APIs involved + flow requirements.
Expected result
Functional integration + end to end tests + interface documentation.
COLLABORATION STANDARDS
A playbook is a conversational script — the context sequence, instruction and iteration that works for a recurring pattern of work.
Situation: You want to improve the quality of pull requests before the merge.
Sequence
Situation: New engineer arrives, needs to understand the project quickly.
Sequence
Situation: You need to migrate codebase — Vue 2 → Vue 3, React Class → Function, etc.
Sequence
CORPORATIVE MEMORY
Knowledge is living documentation — architecture, patterns, decisions, lessons learned. The better documented your knowledge, the more efficient each conversation with Devin.
Architecture diagrams, design decisions, accepted and rejected trade-offs.
Example document: "ADR — Why We Choose Monolith modular over micro-services? What trade-offs were accepted?"
Benefit: When Devin knows architecture, he avoids proposals breaking established standards — without costly rework.
Update: Every major architectural change (~2–4x per year).
Code style, naming conventions, folder structure, component patterns.
Example document: "Style Guide—as we name components, as we structure state, as we write tests on our project."
Benefit: Devin generates code that already follows its pattern — no need for further refactoring.
Update: When default changes (~1x per semester).
What didn't work, traps you've faced, solutions you've found from real mistakes.
Example document: "Old Bugs — 'Performance degrades when N > 10k records because X. The tested and validated solution is Y.'"
Benefit: Devin avoids repeating mistakes you've already learned at cost — without reintroducing known problems.
Update: Continuous — whenever you discover a new drop.
Three incremental exercises. From simple to complex.
From prototype to production-ready.
Demonstration in real environment: Devin CLI at the root of a Salesforce project, connected to the corporate Sandbox Org.
CENARY
You've received a legacy code that works, but it's incomprehensible. 200 lines of nested callbacks. Tight deadlines prevent manual rewriting.
CHALLENGE
Use Devin to refactor without breaking tests.
EXPECTED RESULTS
Functional code, readable, 40 lines, with tests coming through.
Step 1: Legacy code
Step 2: Devin refactors
Step 3: Result
CENARY
Financial calculation function. Testa happy-path, but edge cases appear in production: negative values, overflow, division by zero.
CHALLENGE
Devin generates suite of exhaustive tests that cover 95%+ code.
EXPECTED RESULTS
80+ passing tests, 97% coverage, no false positives.
80 cases · coverage 97% · 0 false positives
CENARY
Integrate 4 external APIs (payment, analytics, CRM, logging) in coherent flow. Timeout, retry, fallback — complex orchestration.
CHALLENGE
Devin creates robust orchestrator with circuit breaker pattern.
EXPECTED RESULTS
Resilient system, tested under failure, tracking logging.
Instead of the agent guessing, he reads. Instead of improvising, he follows a score. That's what separates Vibe Coding of Intent Engineering: the developer does not type less — it specifies more accurately. He acts as a Sovereign Orchestrator, defining architecture, success criteria and restrictions before any execution line.
Refatore esse código.
GenAI returns a refactor that breaks existing tests.
There's no context. It's unclear.
The prompt violated two pillars: Clarity — did not explain Why refactor — and Background — did not mention the existing tests or compatibility restrictions.
Lesson: The tool didn't fail. Communication failed.
Refatore o método getOrders() em
OrderService.cls para adicionar filtro por data.
Restrição: manter assinatura pública. Manter testes existentes passando.
Critério: cobertura ≥ 75%.
Difference: objective + restrictions + measurable criteria.
Refactoring preserves tests. New added date parameter. Coverage reached 92%. PR draft created automatically.
With SDD — Spec Versioned agent reads document structured before any execution. The task is recorded, auditable and reviewed by the entire team.
Always specify the goal. Always include restrictions. Always provide examples the expected result. It goes for most tools and languages.
EFFECT — Less variation: the same spec approaches the behavior between sessions and between people of the team, without making it identical — the agent is not deterministic. When a bug appears, the failure may be in spec, test or code; whoever has authority over the rule decides what to correct.
EFFECT — Antidote to Deskilling: The spec forces you to articulate reasoning before performing. You do not lose understanding — you do documentation. It's what separates people who use AI as crutches from those who use it as levers.
The specification folder as the agent's starting point. It's all in Git. All reviewable before execution.
salesforce-bupj-project/
│
├── force-app/main/default/classes/
│ ├── OrderService.cls
│ └── OrderServiceTest.cls
│
├── sfdx-project.json
│
├── .agents/skills/
│ └── run-tests.md
│
└── specs/
├── _template.spec.md ← Template base
├── 001-filtro-data.spec.md ← Em execução
└── 002-refactor-pagamento.spec.md
devin@sandbox:~$ sf apex test run --code-coverage --result-format human ✓ 12 testes passando · cobertura: 92%
You are in a backend square refactoring payment module. Direct application of Exercises 1-3: refactor, add tests, integrates with CRM.
Gain: 8-hour savings vs. manual refactor. Code 40% more readable. Immediate trust in deploy.
Junior did PR with a bad pattern. Instead of manually correcting, you use Devin as second reviewer. Devin analyzes pattern, generates correct examples, Junior learns by watching the transformation.
Gain: Junior leaves the code review understanding Why, not just What?.
Legacy system without documentation. You use Devin to generate README, ADRs, contribution guides. Documentation Skills applied to real files.
Gain: New engineer onboards in 2 days vs. 2 weeks. Documentation kept alive because integrated into the workflow.
Devin reads the spec. Devin executes Salesforce CLI. Devin runs the tests. You review and decide.
Developer creates or updates spec file in /specs/,
describing the business rule, the Apex module involved and the criteria of acceptance.
vi specs/001-filtro-data.spec.md
Devin interprets the spec, identifies which artifacts Salesforce are relevant and executes the return via Salesforce CLI of corporate Sandbox — without developer needs to list the files manually.
sf project retrieve start --metadata ApexClass:OrderService
Agent locates recovered files, applies described business rule in the spec and updates the corresponding tests. Each modification is guided by criteria of acceptance, which reduces — without eliminating — free interpretation.
edit force-app/main/default/classes/OrderService.cls edit force-app/main/default/classes/OrderServiceTest.cls
Before proposing the PR, Devin runs the suite of unit tests in Salesforce CLI. It only finishes the session and opens the PR if all tests pass with the minimum coverage required.
sf apex test run --code-coverage --result-format human
Test Results: 12 passed, 0 failed · coverage 92%
HANDS-ON · DEMO TO LIVE
$ devin run --spec specs/001-filtro-data.spec.md › Planner: decomposing spec into 4 subtasks… › Executing: sf project retrieve start --metadata ApexClass:OrderService ✓ Retrieved 1 ApexClass, 1 ApexTest from sandbox-bupj › Refactoring OrderService.cls (added dateFilter param) › Updating OrderServiceTest.cls (3 new assertions) › Validating: sf apex test run --code-coverage ✓ Test Results: 12 passed, 0 failed · coverage 92% › PR draft created — ready for review.
This is the actual flow of a Devin session running a Salesforce BUPJ project spec. From the initial command to the PR draft created, the agent operated autonomously. The developer enters only the last step: review the PR. His time was released from mechanical work for strategic work.
REFLEXION
There's no right answer. Just yours.
You're a cognitive orchestrator.
The tool didn't slow you down. He let you go.
ACT III
Now that we have seen the instrument —
How do we play together?
Act III is about culture, team and management. About turning you into strength catalyst for transformation into others.
The surgeon doesn't get the anatomy book in the middle of surgery.
When AI writes code faster than you read, what justifies your presence on the team? The answer is in three dimensions that the AI does not replace: what you know deeply, What you trained to become instinct, and how you use the AI to your advantage.
The five human dimensions that no machine can replicate:
Domain of anatomy
The surgeon mastered anatomy, physiology and surgical techniques during years of study before you step in the operating room. In our world: system architecture, pattern design, application security, data modeling. These foundations do not change when the framework changes.
The AI is the scalpel. But you're the one who operates. Operating with a scalpel without knowing anatomy is dangerous.
Muscle Memory
The surgeon faked hundreds of scenarios before his first real surgery. In our world: post-mortem incidents, crisis simulations, systems debugging complex, strict code revisions. When production drops at 2:00 a.m. and the AI cannot diagnose — it is the muscle memory of the developer that saves.
The AI doesn't feel the pressure of a system out of the air. You feel it. There's no substitute for that.
Rhythm, not brute force
The surgeon doesn't use force to make an incision. Use rhythm, angle, preparation and accuracy. Improvement is not working more hours. It's working more accurately, using the AI as a lever — not as a crutch.
Measuring your development by "how much code the AI generated for you" is the wrong metric. The right metric: what is the complexity of the problems you can solve?
Studying, training, perfecting — it is not for you to work anymore.
It's for you to work Better.
Devin is a brilliant intern.
You still need to be senior.
When each developer uses the AI at their own pace, without alignment, The result is not a symphony. It's noise. Four elements need to be in sync for the team to produce something that goes beyond the sum of the parts.
Process and Planning
No musician sits on the stage and decides what he'll play on time. The score is strategic planning, defined architecture, the agile processes designed and the alignment rituals.
Documented architecture
Refining with clear criteria
Specs Versioned in Git
Backlog with explicit Definition of Done
Without score, effort is lost in improvisation. Each developer It follows its own interpretation and the deliverables do not converge.
Tools and AI
A tuneless violin is not only inefficient — it destroys the presentation of the entire orchestra. Devin, Copilot, Stackspot, IC/CD frameworks and pipelines It's the instruments. They amplify talent, but they need to be chosen, calibrated and used with discipline.
Configured Skills and Playbooks
Integrated tools, not fragmented
Standardization before scale
Corporate context knowledge
A team that uses 17 tools without integration is not being more productive — is creating structured noise.
People and Training
The best score in the world does not sound good if it is performed by those who do not dominate the instrument. Dev, UX, business -- it's the experts. It's the human who feels the emotion of music, applies critical thinking and makes decisions when the Score is ambiguous.
Continuous human development
Critical thinking about AI output
Mastery before speed
Cross-sectional collaboration
Times without investment in human development will continue to produce soulless code — however advanced the AI is available.
Leadership and Synchronism
Maestro is the only person on stage who doesn't produce a single sound. He doesn't play for the musician. What he does — and what no one else on stage can do — It's to make sure everyone gets on the scene in the exact millisecond.
In the AI era, the technical leader evolved to Context Architect: its main function it is not to supervise tasks, but to protect the cognitive load of the team and create the conditions for the Synchronism happens.
Look at the whole, not the instrument.
You know when the team is out of line
Protects collective synchronism
Remove obstacles, do not charge spreadsheets
Documents the context as "team IPA"
Leadership, in the AI era, is not charging deadline. It's about protecting the timing.
Any tool is as good as the judgment that governs it. Vibe Coding teaches that AI is execution, never decision. The developer judging the output is irreplaceable. What you just accept without understanding is disposable.
Clarity, context, examples, iteration are engineering, not etiquette. Agile refinement has become the super-prompt of sprint. If the request gets vacant, the AI executes the error with absolute accuracy and speed. Communication is the primary tool.
No person has all the answers. No AI has. The force is to admit uncertainty and learn along with the team. Teams that learn Together they climb. Devin is a facilitator, not an oracle.
You rule the intelligence that goes into production. Quick code without quality It's a technical debit with interest. Quality is your name on the door. The AI doesn't sign the PR. You sign it.
The tool serves humans. Never the other way around. Vibe Coding wants more contemplative developers, no longer tired. The ultimate goal is no longer speed — it is more freedom for the work that matters.
Vibe Coding is smart governance of smart tools by more and more intelligent people.
If the request is vague, the AI executes the error at the speed of light. The development bottleneck is no longer the typing speed — is the clarity of the decision.
The backlog cannot be a deposit of vague ideas. The PO and the business team They need to specify clearly who is delegating to a senior developer. Refining becomes the moment of construction of the most important sprint prompt.
Kanban is the pre-service stand. In an environment where the AI delivers Too fast tasks, no WIP control the team tries to do eight things at the same time and none of them are fine. The tool doesn't tire out. The human brain, yes.
Sprint is not a deadline for exhaustion. It is the cadence of the trapezista — the balance sheet that gives impulse and the review moment that corrects the route. Scrum is no good for delivering anymore. It serves to ensure that what is being delivered is what It should be delivered.
Scrum Master in the AI era is not a spreadsheet collector. It's the Maestro's extension — one who looks at the whole while each musician looks at his score. The role of agile facilitation is to shield the mind of the external chaos team.
When a metric becomes a meta, it stops being a good metric. The team optimizes the number and not the result. Increase code generation with AI by 55% without scaling validation only creates larger bottlenecks — and delivers speed illusion, not real speed.
Stop measuring what.
Start measuring what for.
FLOW METRICS — WHAT TO MEASURE IN THE YA
It's not chronological time. It is complexity × number of actions that the agent executes. Devin charges for work — the more complex the task, the more ACUs consumes.
dense planning
Decompose complex objectives in verifiable subtasks
Browser Interactions
Browse docs, validate IU, interpret visual results
Local pipelines
Run builds, run test suites, deploy in sandbox
Model Inference
Calls to LLMs during reasoning and code generation
When Devin is awaiting an action from you or waiting for an external service to finish, It automatically enters Sleep mode. In Sleep mode, the ACU counter for completely. You don't pay for waiting.
Esperando sua resposta a uma pergunta → Sleep (contador parado) Aguardando conclusão de uma suite de CI/CD → Sleep (contador parado) Clonando um repositório grande do Git → Sleep (contador parado) Esperando aprovação de PR no repositório → Sleep (contador parado)
The machine does the heavy lifting.
The mastery is still ours.
AI is the most powerful tool our profession has ever seen. She'll chop the onion, calibrate the oven, write the first version of anything. She doesn't get tired, she doesn't complain, she doesn't ask for a raise.
But the thought — that remains yours.
Intelligence before the unexpected — this remains yours.
The judgment on what's right for that client, in that context,
with those restrictions — this remains exclusively human.
The rhythm, the mastery, the ability to make a complex system seem simple for those on the other side: these remain exclusively ours.
You review every AI action before it happens. Maximum security, Lower speed. Use for high-risk tasks or in unknown domains.
The AI performs autonomously; you monitor and can intervene. Balance between speed and control. The default flow of a Devin session.
You define intentions; the IA orchestra multiple agents. Maximum scale. Requires Context Lakes, Playbooks and consolidated governance.
The professional who thrives in cognitive economy navigates the three modes with consciousness — and knows when Use each one. That's the Centauri Intelligence: the human in charge strategic, the machine in tactical execution.
Start small. Measure impact. Itere.
Don't start with the most critical project. Choose something with small scope and result verifiable: a well defined bug, a point refactoring, test cover in existing code. Ideal size: XS or S session.
Use the template in /specs/_template.spec.md. Write the Goal in a sentence.
Define Acceptable Criteria as a verifiable checklist. Include Restrictions.
Read the spec aloud — if it sounds vague, rewrite.
Before using Devin in production, set up what the agent needs to know: security rules, code standards, Salesforce particularities, applicable government limits, deploy policies. A Devin without knowledge is a developer without onboarding.
The efficiencies you discover should not be left with you alone. Standardize repetitive streams in shared Playbooks. A team that shares Playbooks It evolves collectively. A team where each developer invents their own flow loses the most powerful Vibe Coding multiplier: consistency.
After two weeks using Devin, resist the temptation to measure consumed ACUs or generated lines of code. Measure: the time released from the developer was for work strategic or for more mechanical tasks? Has the quality of the code delivered improved? Did the onboarding of new engineers get faster? These are the metrics that reveal if you are using AI to grow — or just to run faster in the same place.
The eight episodes underlying the reasoning of this presentation — for those who want to go beyond the hands-on and understand the complete system.
Thank you.
Keep talking.
Mauricio Yokoyama Issei
Tech Lead
Next step → Devin on Salesforce: Quick Start with Flosum
In short
O Vibe Coding Mature is not prompt chaos: it is structured and persistent intention. The human rises from executioner to Cognitive Orchestrator — directs the machine's intelligence with clear intent, like an executive chef who answers for each dish without cooking them all.
It's the pillar. M0/M3 (Awake/Orquestrate) ed Trust Engineering.
Frequently Asked Questions
Vibe Coding is developing software driving an AI agent by intention instead of typing each line. In the mature form, the intention is structured and persistent (a versioned specification), not an ephemeral prompt — it is what separates the experiment from the method.
In SDD the versioned specification is the reference of intention: write what and why, and the AI implements against the spec, with tests (BDD) to verify. Spec is not infallible: when spec, tests and code differ, a person with authority decides what to correct. When the intention lives in a disposable prompt, it gets lost; in a spec version in the repository, it can be reviewed and audited.
It is the professional who directs the machine's intelligence with intent — defines what and why and judges the result — rather than executing each line. It consumes typed schema-derived tools and versiones not only the code, but the reasoning that produced it.
It is the arsenal of organizational intelligence that grows over time: Skills are reusable procedures (refactoring without risk, testing exhaustively), Playbooks are process recipes (code review, onboarding, migration) and Knowledge is the asset that accumulates (architecture, conventions, lessons and drops).
It is the evolution of the MCP from the query to the rendering: the agent uses the protocol to issue interface intent — the Brain decides what to show (data under contract) and the deterministic display decides how to render. The interface ceases to be unpredictable free text and becomes ruled, testable and reproducible output.