---
title: "Learnings from moving my Grok Bots to Devin Bots"
description: "What worked, what got in the way, and why I ended up using both."
canonical: "https://www.rickblalock.dev/scratch-notes/learnings-from-moving-my-grok-bots-to-devin-bots/"
date: "2026-11-17"
updated: "2026-11-17"
author: "Rick Blalock"
---

# Learnings from moving my Grok Bots to Devin Bots

> What worked, what got in the way, and why I ended up using both.

Published: 2026-11-17

Catalog: SN-032

I had the privilege to use Devin Bots during the beta, roughly November 12–17, 2026. Everything here comes from those few days. So this is an early report / friction log of the experience.

> Important: I'm going to try to keep this as close to a qualitative report and friction log as possible.  But allow me to diverge at the start:
>
> The experience of Devin Bots is really good and works really well and it has a bright future for which I'm very excited about.  I want to state that early on here since the nature of this post is more a ***"friction log"*** and can sound more negative than it really is.  My hope is someone in Cognition just points Devin to this post and says "Go fix all his frictions, great or small, make no mistakes" and it just gets that much better.

**Quick TLDR:**
I moved a broad version of my Grok Bots to Devin to see how it worked (I'll document what I did further below). The port succeeded and cost about $300 in one-time Devin usage.  Probably took an evening's worth of time. Things worked really well for a lot of things. Devin was proactively fixing things, making suggestions, and managing a decent amount of engineering work.  Within the first few days I ran into enough limitations with business work that I moved that side back to Grok Bot.  Now I'm on a hybrid Grok Bot <> Devin Bot setup for the time being.  I didn't set out to do this but it's an unexpected and decent setup since they can all talk to each other.  More on that later.

To level set on some things about me, as a user background/persona, just so the review has some mooring:
- I've used Devin since nearly the beginning
- I've used Grok Bot since it's come out
- I've built my own version of both of these over the course of 2 years, both local and cloud versions
- I've been working in agentic cloud infra for the last 2 years
- I'm absurdly agent-pilled and not-normal, in a state of agent-psychosis that is probably not healthy

Point being, as a user I'm fairly familiar with the concepts ahead of using this product, which brings some expectations and baggage, etc too.

Some further background on my previous setup includes: I already had a team of Bots in Grok covering product management, finance, search, content, "lab" (autoresearch), and other business work.

## What Devin Bots are

Cognition describes Devin Bots as persistent *engineering* teammates. In its framing, a session completes a task, while a Bot owns an ongoing responsibility: it retains context, leads teams of Devin sessions, works with other Bots, and brings the decisions that need a person to a "Needs You" inbox.[1](https://devin.ai/blog/introducing-devin-bots)[2](https://devin.ai/bots)  Also, note the framing, "engineering teammates", which admittedly I tried to move all my Grok Bots over, not just engineering.

Cognition's public examples are engineering work: development, QA, releases, monitoring, prompt tuning, and layout checks. Walden Yan described the company's internal approach as "extreme automation," including Bots that built other Bots.[3](https://x.com/walden_yan/status/2122740852091216274)

That is Cognition's description. My own adjustment was simpler. I had always used Devin by starting a session, giving it a coding task, and reviewing the result. Bots have identities, responsibilities, routines, and memory, and they start sessions themselves. The curious thing here is my brain still thought in sessions while the product asked me to think in coworkers.  This didn't happen to me with Grok Bot.  I suppose it's a mental friction of just legacy understanding of Devin.  It does show the sessions under a bot though so that might be part of it.  I got over that within a day though and now I like the mix.

## How my experience worked out

### How I moved the team

I did not rebuild each Bot by hand. The sequence was:

1. **Audit each Bot.** I had my Grok Bot Chief of Staff audit every existing Bot: its purpose, recurring routines, skills, and responsibilities.
2. **Dump the skills separately.** I generated a complete inventory of the shared skills the Bots used, routines, etc.
3. **Map Bots to skills.** A simple map showed which Bot used which skill.
4. **Add examples.** I included concrete examples of completed work.
5. **Give the package to Devin.** I dropped all of it into Devin.
6. **One-shot recreation.** Devin created the Bots from that package in one pass.
7. **Plugin packaging.** Devin packaged the shared skills as a Devin plugin, so I did not have to rebuild and assign each skill by hand.  That was pretty cool.

Once the package was complete, the basic setup worked without trouble. The surprise was the bill: about $300 of Devin usage for the port (Fortunately I had some credit and support for this). It felt effortless, and nothing in the process told me how much work was running underneath.

I would use this method again, but I would cut the roster down to roles that belong in Devin before importing anything. For example, moving my CFO over was a bit of a disaster.

### Why I ended up hybrid

The first version put almost everything in Devin: product GMs, finance, SEO, content, SRE, releases, and several engineering roles.

Within the first few days I moved business, marketing, finance, content, SEO/AEO, and operations back to Grok. Sales had stayed in Grok from the start. Four things drove that:

- **Coding-first fit.** Devin is a coding product first, and its Bots feel that way next to a general-purpose Grok Bot. Work that ends in a pull request suits it. Work that ends in a post, a ledger entry, or a publishing queue did not suit it as well.  So much so that the gravity of Devin bots is to pull you into review things constantly.  I could not, despite all my prompting and skills and routines and rules I tried to set up, get it to stop asking me for things.  Sometimes it would understand it doesn't need me to review or approve a PR and other times it'd forget (as a quasi-engineering example).
- **Connector and account limits.** In my setup, business work spans several accounts for the same service (e.g. Google Workspace). However, Devin could keep one Google Drive login at a time, and the same limit applies to anything where I have more than one account it seemed.  For my CFO, I ended up having it share a spreadsheet to the one account Devin could access (across to another business).  The hack worked but not ideal.
- **Fragile browser authentication.** Where a service had no connector, the fallback was signing in through a browser. Those logins were short-lived and tied to one machine, and Devin Computer often stalled during sign-in.  I told it multiple times to store it, stay signed in, etc. but it just could not get it straight.
- **Premature capability refusals.** Bots sometimes said a business task was impossible before checking what tools they had.

So I split it up and kept Grok Bots as the business/product side of things and Devin bots as their engineering arm: kept code, pull requests, builds, releases, deployments, dependency and CVE work, SRE, and technical investigations.

```text
Rick
  Grok Chief of Staff
    Business GMs
    Marketing, content, finance, SEO/AEO, sales, operations

  Devin Chief
    Product engineering counterparts
      5 separate product engineering arms that mapped to the business GMs.
    Technical lanes
      Software Factory, Bug Catcher, SRE,
      Release Bot, iOS Engineer
    TA for my direct one-off asks
```

The Grok GMs decide what the business needs. Their Devin counterparts own the technical follow-through. The tree shows routing; a lane can serve more than one product.

The automation snapshot (mentioned later here) in the export reflects the split: 60 retained routines, 20 enabled and 40 disabled. Many of the disabled ones are business jobs that went back to Grok or duplicate checks I removed. Disabled does not mean they failed.

This is my result after a short beta with my mix of products and accounts. I am not offering it as a rule for anyone else.

### The intended work loop

This is the loop I designed. It is the target, and the Bots did not always hit it.

1. I ask Chief, or a product owner reports a problem.
2. Chief routes it to the owning product GM and technical lane.
3. The lane starts a bounded Devin session to inspect, implement, test, or investigate.
4. The session returns evidence: test output, a screenshot, a recording, a pull request, or a deployment record.
5. The GM checks the result against the brief.
6. Chief sends me one "Needs You" card if a decision is required.
7. After approval, the owner performs the exact approved action and records proof and a rollback point.

Approval, merge, deployment, verification, and rollback stay separate events throughout.

Where things matched the loop:

- Chief bundled eight related security pull requests into one approval. The bot owner then merged them one at a time and reran checks as each landed.
- One product GM reported that a small visual fix had merged but the live site had not changed, because that hosting project was not connected to Git. It took a separately approved manual deployment, then a check of the live page with a screenshot and a rollback version. The merge and the deployment were handled as two separate steps.

Where it missed:

- Chief's own notes recorded nine report routes silently failing with permission errors. Release Bot reported that after one deployment it could not deliver the post-deploy handoff to SRE or the product GM, so the keep-or-roll-back check did not arrive through that route. NOTE: It seems like since this happened Cognition has made the "Sharing" permissions for bots clearer and easier to manage.
- The "Needs You" card had no in-place Approve, so step 6 mentioned above sent me out of the Bot surface to finish the decision.  I've noticed that at times these approval cards get lost in the shuffle when diving into what they're trying to get me to decide.
- The first night, a "surprise me" routine carried over from the port ran overnight and exhausted my ChatGPT subscription usage without any of it surfacing as a decision.  It was nearly full when I went to bed. Oh yeah, you can use your ChatGPT subscription btw. That's cool.  EDIT: Looks like Cognition has added some budget controls per bot now, which is great.  Still not sure how it'd use all my usage but that is helpful.

### Devin bot usage audit

On November 17 I had the Devin side produce an audit from its own session export.

*Note that this is my personal Devin account so the usage numbers prior to the Devin Bot product are of small-ish usage.  I usually max out my Devin Max subscription every week but not always.*

The export showed 432 session records created from November 13 through the partial November 17. The entire earlier part of the export, which starts March 21, has 410. Daily sessions went from 1 on November 12 to 175 on November 13, then 110, 49, 62, and 36 on the partial last day. Of the 432, the export attributed 429 to Bot service users rather than to me.

![Session records per UTC day from November 1 to 17, 2026; November 17 is partial.](/assets/scratch-notes/learnings-from-moving-my-grok-bots-to-devin-bots/sessions-per-day.webp)

These are session records, not 432 completed projects. Sessions include coordination, review, investigation, and maintenance.

The category labels in the export shifted between the two cohorts: code review went from 24 to 107, production investigation from 8 to 56, and feature development from 129 to 34. It's curious to see that this supports a change in the approach of the work, toward review and investigation and away from me starting feature sessions. I suppose it's not that surprising considering I was using this as a general purpose bot/agent and not session based tasks. It doesn't really say anything about productivity.  Which speaking of that: I tried to build out an engineering performance management view (DORA-esque) for all the bots but I couldn't get the data as it's not exposed in the Devin MCP or APIs.  You can get them out of the UI and a private API but I didn't want to dive into that.

The same cohort links to 166 distinct pull request URLs marked merged at export time.

### How Grok and Devin talk

The two sides exchange work in three ways:

- **Shared artifacts in [System of Reason](https://systemofreason.com/).** Handoff packs, findings, drafts, and decisions live in a store both platforms can read. Git stays the source of truth for code and rules obviously.
- **Bot-specific email aliases.** A Devin Bot reports to a specific Grok Bot through that Bot's own tagged alias. The first line of the message says which Devin Bot sent it.
- API/MCP comms from Grok Bot to Devin Bot is pretty useful.

Direct Devin-to-Devin messaging also exists, but it depends on sharing permissions and reply subscriptions. The details are in Hot tips.

## The principle: decisions, not status updates

The rule I gave the team is short: treat me like a VP. Bring me decisions, exceptions, risks, recommendations, and the evidence behind them. Do not make me read the coordination feed, don't make me review PRs, don't bring stupid little things that they can figure out themselves, etc.

I wrote about the general idea in a Scratch Note, [Your agents are giving you too much to manage because you're doing it wrong](https://www.rickblalock.dev/scratch-notes/your-agents-are-giving-you-too-much-to-manage-because-youre-doing-it-wrong/), and my decision rules for the Bots came out of it. I will not repeat it here. What matters for this review is how Devin Bots measured against it.

An eight-pull-request bundle was the principle working. Eight changes were investigated, fixed, and tested, and I made one decision.

Three things worked against it:

- **Noisy history.** The Bot message list filled with near-identical rows, which made it hard to find the activity that mattered. Really, I don't actually care, I'm not supposed to have to dig into those details right?  But I did peek from time to time to try to understand the system more.
- **No in-place Approve.** A card that asks for a decision should let me make it there.  Sometimes there was that action and other times there wasn't.  EDIT: I did notice today that there are more approval actions now showing up, so that's good.
- **Overnight routine burn.** A routine consumed my usage while I slept, and nothing told me until it was gone. Spend at that level is an exception I should have heard about. Like I mentioned above though, spend controls are now in, so that will help a lot!

Some other rules I set: reserve money, public communication, customer-visible actions, production deployments and migrations, and changes of goal or scope for me. A Bot can propose more authority after a record of accepted calls, but I approve any expansion.

## Pros

### The port worked

As mentioned before: The audit, skills inventory, map, and examples gave Devin enough to recreate the team in one pass and package the skills as a plugin. Once ported, the basics of creating and running the Bots worked well.

### Orchestration and compression

This is the strongest part. The Bots routed technical work, started bounded sessions, collected evidence, and compressed related updates into one decision. One Bot coordinating many sessions is a real improvement over me managing a list of coding chats.

### Evidence came with the handoff

The better workflows returned proof with the result. Two examples, both as the Bots reported them:

- Release Bot reported that deployment documentation for one product was out of date, and that following it could have switched off features existing users already had. It opened a pull request to correct the documents and held it for my review.
- In another case, a test exceeded its time limit and stopped a deployment partway. SRE reported which parts had shipped and which were still on their previous versions. Release Bot then took over the remaining work, so two Bots were not claiming the same deployment.

A third Bot reported that a batch of apparent production payment failures were sandbox test events sent to a live endpoint, with no live payment affected. It raised no incident, but did fix it, which was the right outcome.

### Approval while trust is forming

I liked seeing Bots ask for approval after they had investigated and tested something. Early on, that visibility builds trust. Constant approval cannot be the permanent model, though, and I have not yet reached the point where routine classes of work run without me. That is still an open friction for me.

## Cons

### Cost visibility

There are two separate cost facts.

First, the port from Grok Bots to Devin Bots used about $300 of Devin usage, once.

Second, and unrelated to the port cost, I enabled ChatGPT usage in Devin and woke up to find it completely exhausted by a "surprise me" routine that had carried over.

I could not see how it used that much, because at the time Devin had no breakdown by Bot, routine, or session. The product needs that reporting, with model usage, machine time, date ranges, alerts, and hard limits. Without it I cannot judge whether a given Bot is worth what it costs, and I am making no claim here about return or time saved.

### Sharing and permissions

~~It was not clear what Share exposes or to whom. I ended up sharing everything broadly to get the team working, which is not the permission model I want.~~

~~The audit showed this was more than confusing UI. Selecting another Bot as a recipient was not enough; the target Bot had to be shared from its own settings, and replies needed the right subscription to come back. When that was missing, messages failed quietly. Connections and secrets also do not pass from one Bot to another. That is the safer design, but the product does not make the boundaries easy to see.~~

EDIT: This seems to have been addressed now.

### Connectors and authentication

Connectors assume one account per service. I have several for some services, and each Bot needs to know which one it is using.

Browser logins are a weak fallback. They are temporary, tied to one Devin machine, and not reusable by other sessions.

Devin Computer often crashed or stalled during sign-in (Out of memory a lot). Recurring work needs service accounts or scoped credentials stored in Devin Secrets.  The service account and keys are easy.  The browser work, I just had to constantly log in for my bots, over and over.

### Capability awareness

Devin often decided it could not do something before checking its tools. A missing native connector became "can't" without a look at APIs, browser access, plugins, secrets, or remote machines. I had to push it to notice capabilities it already had.

### Rules and shared state

A rule file sitting in a plugin does not prove a Bot loaded it. Chief's plugin notes recorded that always-on rules need the right trigger setting, or they never reach a fresh session.

### Product UI

Now I'm drifting into personal taste.  I've always thought Devin had one of if not the best coding agent UIs and UXs.  For the most part it stays the same but now with this bot layer on top.  That particular part still feels like a beta. The roster is dense, history rows or actions of other bots repeat a lot and make it easy to just ignore or even ask, "Why is this here", icons and messages go missing (especially on mobile), status and menus collide, the sidebar needs its own scrolling, and mobile can be unreliable. Individually these are small. Together they make a team of Bots harder to manage than the underlying work deserves. The dated specifics are in the friction log I sent along to Cognition.

## My opinion

This is a provisional verdict after a few days of beta use.

Devin Bots are a meaningful improvement over managing many coding sessions by hand. The value is orchestration: holding a technical responsibility, routing work, collecting proof, and reducing several engineering updates to one decision.  Having the software factory address things it saw without me prompting it is certainly delightful.

They were not always hands-off for me though. Cognition's promise of bringing me only the decisions that need me is absolutely the right direction but it wasn't always my daily experience.  Or, actually, now that I write this I realize maybe it was bringing me too many decisions (not the right ones).  See my comments earlier on about "Treat me like a VP".

Measured in the present time: I would use Devin Bots for a multi-repository engineering operation. I would not use them today as the only system for running a business. For now I am keeping Grok as the business layer and Devin as the engineering layer, and I expect to revisit that as the product matures.  I'm expecting in 10 AI years or so (like...2 human weeks), most of this stuff will get addressed and I can run everything on Devin.

## Hot tips

### Build the migration package first

If you're coming from something like Grok Bot, follow what I mentioned earlier.  It works and is easy: Tell a Grok Bot to audit each Bot, dump the skills separately, map skills to Bots, and add examples before you import. Then cut the roster to the roles that belong in Devin. The port is easy enough that you can move more than probably SpaceXAI wants you to.

### Getting Grok Bots and Devin Bots to talk

If you're even interested in this type of thing: What worked in my setup, according to Chief's recorded routing notes and the failures the audit turned up:

1. **Put handoffs in a shared store.** e.g. A Grok GM writes a handoff pack to shared [System of Reason](https://systemofreason.com/) artifacts (use whatever works for you...emailing works too!). Its Devin counterpart reads it, does the engineering work, and writes findings and results back to the same place. Neither side depends on files that live on one machine.
2. **Report to the Bot's own alias.** Each Grok Bot has its own tagged email alias. Use the alias of the Bot you mean to reach. Mail sent to a generic inbox, or to the wrong tag, may never reach that Bot.
3. **Identify the sender.** Start the message with which Devin Bot is reporting.
4. **Route through the chiefs.** For me, reports go through Devin Chief. When customers, money, or public posts are involved, Grok's Chief of Staff is copied.
5. **For Devin-to-Devin messages, set up both ends.** Share the target Bot from its own settings, and turn on the reply subscription so answers return to the thread that asked.
6. **Test the return path.** Send a test in each direction and confirm it arrived. A message that looks sent has not necessarily been delivered.

### Running a software factory

The pattern that held up:

- **One owner per pull request.** One session owns the pull request and writes its status. Other Bots do not edit it.
- **Separate intake from repair.** Bug Catcher looked for fresh regressions. Software Factory owned the fixes and follow-ups.
- **Bounded sessions with a pass check.** Each ticket records the owner, scope, pass check, and evidence.
- **The author proves the change.** Whoever makes a UI change supplies the browser proof. I did not keep a separate QA lane for it. You'll save time and tokens.

### Keep passing checks quiet

Have routines speak only on an anomaly or a decision. Passing checks belong in a digest or the record.

### Not covered here

I planned tips on hooking up a remote computer and on T3 Code. I do not have setup steps I have tested well enough to publish, so both need a separate guide.  This does work though, I promise!

---
## Original Friction log

These are my notes from the beta, lightly edited, in the order I wrote them.

### November 12

- I need more than one instance of the same connector, for example multiple Stripe accounts, each labeled clearly enough that the Bot targets the right one.
- A Bot can reply in-thread in the app, but not from the right-click menu where I looked first.
- The mobile app sometimes doesn't show the feed, and getting to Bots on mobile isn't easy or clear.
- Devin is first and foremost for coding, and its Bots feel coding-focused next to a general-purpose Grok Bot.

### November 13

- Dropped the migration package into Devin and it created the Bots. Once everything was ported, it worked really well.
- The port took about $300 of Devin usage. That was not obvious from how effortless it felt.
- Wowzers, it uses tokens. I enabled ChatGPT usage, went to bed, and woke up to find it completely exhausted by a carried-over routine.
- I can't see spending by Bot, routine, or session, so I can't tell how it burned that much.
- The "Needs You" card explains the fix but only offers Dismiss and View PR. I want to approve right there.

![Devin Needs You card with Dismiss and View PR controls but no Approve action. Product details are redacted.](/assets/scratch-notes/learnings-from-moving-my-grok-bots-to-devin-bots/needs-you-missing-approve.webp)

- The review card and the message input sit too far apart to feel like one workflow.
- The Bot message history is full of near-identical rows with the same icon.

![A list of repeated Devin Bot message rows with nearly identical labels.](/assets/scratch-notes/learnings-from-moving-my-grok-bots-to-devin-bots/noisy-bot-message-list.webp)

- Bot icons sometimes don't appear in the list. The sidebar makes me scroll to see every Bot. The activity indicator and the row menu collide. Switching Bots is ever so slightly too slow.
- Devin can keep only one Google Drive login at a time. To reach a folder in a second account I have to share it across accounts, because reconnecting would drop the first.

![A Devin Bot explains that it can hold only one Google Drive sign-in. Account names are redacted.](/assets/scratch-notes/learnings-from-moving-my-grok-bots-to-devin-bots/single-google-drive-account.webp)

- A browser-based Google login is temporary and tied to one Devin machine. Other sessions can't reuse it.
- I don't understand what Share exposes or to whom. It sometimes didn't seem to work, so I put everything on Share.
- There is comfort in Bots asking for approval right now. I don't know yet when that turns into fatigue.
- My brain still thinks in sessions.

### November 15

- Chief concluded Bots could not manage YouTube because there was no native connection, without first looking at other routes.

![A Devin Bot says it cannot manage YouTube because no native connection exists.](/assets/scratch-notes/learnings-from-moving-my-grok-bots-to-devin-bots/youtube-capability.webp)

- Devin Computer stalled on a blank YouTube Studio page during sign-in. This happens a lot with external sign-ins.

![Devin Computer stalled on a blank YouTube Studio page during sign-in. Identifying details are redacted.](/assets/scratch-notes/learnings-from-moving-my-grok-bots-to-devin-bots/computer-sign-in-stall.webp)

- Around this point I paused the business and marketing automations in Devin and kept them in Grok.

### November 17

- Cognition launched Devin Bots publicly. My beta notes end here.

## Appendix: the audit numbers

These come from the audit the Devin side produced on November 17 from its own session export. Product, repository, and account names are left out.  *Note that this is my personal Devin account so the usage numbers prior to the Devin Bot product are of small-ish usage.  I usually max out my Devin Max subscription every week but not always.*

What the data can and cannot say:

- Days are UTC. November 17 is a partial day.
- The export starts March 21, 2026. "Before" means everything from then through November 12, not a matched five days.
- A session is one record. It can be coordination, review, investigation, or maintenance, not only a finished piece of work.
- Sessions are attributed to whichever Bot account started them. That does not prove which Bot owned the work.
- Categories are the labels in the export. Nobody audited them.
- Pull request state is the state on export day. There are no merge dates, and a review session can link a pull request it did not write.

### Sessions

| Period | Sessions | Started by Bots | Started by me |
| --- | ---: | ---: | ---: |
| March 21 to November 12 | 410 | 0 | 410 |
| November 13 to 17 (partial) | 432 | 429 | 3 |

### Sessions per day, November

| Day | Sessions | Day | Sessions |
| --- | ---: | --- | ---: |
| Nov 1 | 8 | Nov 10 | 2 |
| Nov 2 | 0 | Nov 11 | 1 |
| Nov 3 | 5 | Nov 12 | 1 |
| Nov 4 | 12 | Nov 13 | 175 |
| Nov 5 | 5 | Nov 14 | 110 |
| Nov 6 | 7 | Nov 15 | 49 |
| Nov 7 | 17 | Nov 16 | 62 |
| Nov 8 | 0 | Nov 17 (partial) | 36 |
| Nov 9 | 7 | | |

### Sessions by Bot, November 13 to 17

| Bot | Sessions |
| --- | ---: |
| Engineering lanes the audit did not map to a single Bot | 204 |
| Product GMs (5 combined) | 84 |
| SRE | 59 |
| Chief | 34 |
| Release Bot | 19 |
| TA | 12 |
| Comms | 7 |
| SEO | 6 |
| CFO | 4 |
| Me | 3 |
| Total | 432 |

### Session categories

| Category | March 21 to November 12 | November 13 to 17 |
| --- | ---: | ---: |
| Code review | 24 | 107 |
| Production investigation | 8 | 56 |
| Bug fixing | 52 | 55 |
| CI/CD and DevOps | 63 | 55 |
| Feature development | 129 | 34 |
| Research and exploration | 41 | 25 |
| Other | 1 | 21 |
| Data and automation | 12 | 20 |
| Documentation and content | 17 | 19 |
| Migrations and upgrades | 7 | 17 |
| Unit test generation | 7 | 13 |
| Not recorded | 15 | 6 |
| Refactoring and optimization | 14 | 4 |
| Security | 18 | 0 |
| Code quality and security | 2 | 0 |
| Total | 410 | 432 |

### Pull requests linked to the November 13 to 17 sessions

| State on export day | Distinct pull request URLs |
| --- | ---: |
| Merged | 166 |
| Closed without merging | 8 |
| Open | 3 |

### Routines on November 17

| Purpose | Enabled | Disabled |
| --- | ---: | ---: |
| Housekeeping and opportunistic checks | 10 | 18 |
| Reliability and technical risk | 6 | 2 |
| Engineering and data safety | 2 | 1 |
| Governance | 2 | 0 |
| Business reporting and content | 0 | 11 |
| Search and discovery | 0 | 5 |
| Finance | 0 | 3 |
| Total | 20 | 40 |

Disabled means switched off and kept. It does not mean the routine failed.

## Sources

1. [Introducing Devin Bots: From Tasks to Outcomes](https://devin.ai/blog/introducing-devin-bots)
2. [Devin Bots product page](https://devin.ai/bots)
3. [Walden Yan on extreme automation with Devin Bots](https://x.com/walden_yan/status/2122740852091216274)
4. [Cognition's public launch post](https://x.com/cognition/status/2122737511684587551)

---

[All Scratch Notes](https://www.rickblalock.dev/scratch-notes/)
