Poke × Devin
Your conversational command center for Devin
Turn a text into autonomous engineering work. Ask Poke to start a Devin session, track it as it runs, and review a ready-to-merge PR - all from one conversation.
Ask · Track · Review · Ship
How they work together
One request, a full loop of autonomous work
Poke is the front door and the messenger. Devin is the engineer. Together they take a sentence and turn it into shipped code.
Ask Poke
Tell Poke what you need in plain language, from a text, a chat, or a web message.
Poke starts Devin
Poke turns your request into a Devin session and hands it a clear brief.
Devin plans, builds, tests
Devin explores the code, implements the change, and runs the tests on its own.
Poke keeps you informed
Poke relays progress and status updates as Devin works, so you never chase it.
You review and ship
You get a summary with a PR ready to review, then approve and merge.
Text Devin from Poke
Ask in plain language. Devin gets to work.
You never open a terminal or write a ticket. You just message Poke, and Poke turns your words into a Devin session, then keeps you posted until there is a PR to review.
Poke × Devin
Session: checkout test
Poke, ask Devin to fix the flaky checkout test and open a PR.
9:41
On it. Starting a Devin session for the checkout test runner.
9:41
Devin is working - exploring the checkout test suite.
Devin found the flaky assertion and is rewriting the test.
9:43
Devin opened PR #482 - checkout test now passes 12/12 runs.
Nice. Ask Devin to bump the timeout config while it's in there.
9:48
Added to the session. Devin will follow up and update the PR.
9:48
Illustrative example - not a live chat
What Devin handles
The hands-on engineering, handled
Devin works through the whole change autonomously. These are the kinds of tasks it takes on, described as workflow examples rather than promises.
Autonomous software engineering
Devin takes a task from a brief to a working change without hand-holding.
Codebase exploration
It reads the code, finds the relevant files, and maps the change before writing.
Implementation
Writes the code, follows the repo's conventions, and keeps the diff focused.
Debugging
Reproduces issues, traces the cause, and fixes the root problem.
Testing
Runs the suite, fixes what breaks, and adds coverage where it matters.
Pull requests
Opens a PR with a clear summary, ready for you to review.
Workflows that compound
Poke orchestrates. Devin executes.
Poke is built for orchestration and communication - routing work, chasing status, and reporting back. Devin does the engineering. Together they handle the workflows below.
Bug triage
Poke collects the report, Devin reproduces and fixes it, and you review the PR.
Poke, ask Devin to reproduce the checkout error and open a PR with the fix.
Feature shipping
Describe the feature to Poke. Devin plans, builds, and tests it end to end.
Poke, ask Devin to build the settings page and add tests for it.
Dependency upgrades
Devin runs the upgrade, resolves breaking changes, and verifies the build.
Poke, ask Devin to upgrade the auth library and fix any breaking changes.
Incident follow-up
After an incident, Devin digs into the logs and ships the remediation.
Poke, ask Devin to investigate the timeout spike and open a fix.
Research and prototyping
Devin explores options and returns a working prototype for you to evaluate.
Poke, ask Devin to prototype an export-to-CSV flow and report back.
Scheduled and triggered work
Poke runs Devin on a schedule or on an event, then reports the outcome.
Poke, run Devin every Monday to bump stale dependencies.
Manage every Devin session
Full visibility, full control
Start a session, watch it work, steer it, and stop it when you are done. Every Devin session stays under your control.
Start a session
Ask Poke to start Devin on a task. It creates a session and a clear brief.
Check status
Poke reports where each session stands, so you know what is moving.
Send follow-ups
Add instructions mid-flight. Devin picks them up and keeps going.
Review output
Get a summary and a PR. Look it over, request changes, or approve.
Terminate a session
Stop a session when it is done or off track. You stay in control.
Devin sessions
3 active this morning
| Session | Status | Started | Output |
|---|---|---|---|
| fix-checkout-flaky-test | Working | 9:41 | PR #482 |
| upgrade-auth-deps | Needs input | 8:12 | — |
| add-billing-webhook | Completed | 7:30 | PR #479 |
Quick start
Three steps to your first Devin session
Copy a prompt, send it to Poke, and watch the loop run. These are starting points - adapt them to your own task.
Start a session
Ask Poke to hand a task to Devin. Keep it concrete: the goal, the repo area, and what you want back.
Poke, ask Devin to fix the flaky checkout test and open a PR.
Follow up while it works
Send adjustments without restarting. Devin folds them into the same session.
Poke, tell Devin to also bump the timeout config.
Review and ship
Poke brings back a summary and a PR. Approve the change and merge it.
Poke, summarize what Devin changed in PR #482.
FAQ
Common questions
How the Poke and Devin loop actually works, in plain terms.
What does Poke do, and what does Devin do?
Poke is the conversational layer. It takes your request, starts and manages Devin sessions, and reports back. Devin is the autonomous engineer. It does the hands-on work: exploring the code, writing, testing, and opening PRs.
Is the workflow synchronous?
No. You ask Poke and move on. Devin works in the background, and Poke sends you status updates as it goes. You review the result when it is ready, on your own schedule.
How do follow-ups work?
Send Poke a follow-up at any time, like asking Devin to adjust the approach or add a change. Poke routes it into the running session, and Devin picks it up and keeps going.
What should I expect when reviewing?
Each session ends with a summary and a pull request for you to review. You approve, request changes, or stop the session. Devin does the heavy lifting, but you make the call on what ships.
Turn a text into shipped work
Start with one sentence. Poke hands it to Devin, keeps you posted, and brings back a PR for you to review.