Devin uses autonomous AI programming assistant to fix problematic code for open source community

Today we are announcing Devin Open Source Program.

As part of the official launch of Devin, we're offering a Devin Team Plan quota of 500 free ACUs to selected open source project maintainers. Visit app.devin.ai today to sign up and contact us at osi@cognition.ai to join.

Open source projects often have a large backlog of unresolved issues. The sheer number of small issues that need to be fixed can quickly overwhelm maintainers, and Devin is the ideal partner to handle these tasks - by taking care of minor tasks in the background, Devin helps maintainers focus on critical tasks.

Here's what Devin has already contributed to the open source community:

Anthropic MCP

Pull request: https://github.com/modelcontextprotocol/inspector/pull/105

Devin session: https://app.devin.ai/sessions/266955553baf40cfa7fdd32d42ab219d

In this project, Devin is working on a project for MCP Server debugging interface project inspector Added a new feature that shows function negotiation.

Question: https://github.com/modelcontextprotocol/inspector/issues/85

Devin began by using a browser to investigate how feature negotiation works:

After Devin writes the code, some key features help ensure proper testing:

1. Code repository settingsBefore you start your Devin session, you'll need to install the MCP server for Python. Before starting a Devin session, we started the Python MCP server by installing the uv to set up Devin's virtual machine.
2. knowledge-related. We can either manually tell Devin how to test the code, or add this information to its knowledge base so that Devin automatically remembers it in future sessions.

This setting allows Devin to verify that code changes are valid in the browser:

Once the code is tested, the maintainer can review it.

Dagger.

Pull request: https://github.com/dagger/dagger/pull/9130

Devin session: https://app.devin.ai/sessions/2afcdb9847ff416382ee6126bc77ee8c

Devin's PR addresses a low priority task in the Dagger project.

While Devin was eventually able to fix the problem, it sometimes required multiple round trips to make adjustments.

Devin's Github integration simplifies this process with PR comments and CI checks. Any PR comments can be automatically sent to Devin via Webhook.

Finally, make the most of Devin and don't expect perfect PRs from 100%. While Devin can do what 80% can do, there is still a need to manually ensure the quality of the end result. For example, removing redundant code differences before merging. In this PR, Devin added debug logs that will need to be manually removed later.

Read more about How Devin Brings Value to Dagger

Not someone who works in AI, but an AI team member. It's a fascinating experience and a glimpse into what's possible in the future.

At Dagger, we're a small team building a complex engine with a growing list of usage scenarios. Like many open source projects, we face the challenge of maintaining the "long tail" of problems - small tasks that are important but not urgent enough to be of high priority often pile up. That's what I think of when I hear about Devin, a member of the AI team.

A typical open source problem

Here's a familiar story: someone reports a problem that's not too big - maybe a little annoying but not urgent. At Dagger, we're very focused on product excellence, but the to-do list was too long. These kinds of issues get logged, but they're not a priority and get shelved. Three months go by and no one has time to look at it. At best, it gets categorized quickly; at worst, it disappears into the abyss of GitHub issues.

For example:Issue #8195. One contributor pointed out a small but legitimate pain point in our workflow. Without Devin, this issue might have stayed in a pending status. But with Devin on the team, we asked, "Can you handle this?" And it did.

Within minutes, Devin submittedA pull requestThis PR required some manual review, but its core implementation was functionally correct from the start. This PR required some manual review, but its core implementation functioned correctly from the start, and Devin even followed up with our feedback, iterating until the PR was ready to be merged.

This feels like a solid contribution from a smart beginner developer - one who's new to the codebase but eager to learn and improve. It's just that Devin is an AI. the way it works seems completely natural.

If you're interested, you canWatch the full session. You'll see how it solves problems, adapts to feedback, and produces meaningful results.

Teaching Devin to develop Dagger

Devin is different from the average developer, but managing Devin is familiar in some ways; Devin is very "book smart", but not quite "real smart", like some very smart junior developers. The key to making Devin valuable is both choosing the right tasks and training it in a smart way. One of the most amazing things about Devin is how smoothly it learns.

We provide feedback through the app and directly on GitHub, and Devin handles both seamlessly.

Then we took it one step further: we taught Devin how to use the Dagger Development Dagger Because our build and test environments are fully containerized with Dagger, Devin doesn't need CI at all. Because our build and test environments are fully containerized through Dagger, Devin doesn't need a CI at all. it can run its own CI locally, verify that it works and report the results in comments. When humans need to reproduce the results, we simply use the same containerized environment that Devin has configured!

This is not only a time saver - it's a "Oh, my God" moment It revolutionized the way we think about development workflows. It revolutionized the way we think about development workflows, and Devin's ability to automate testing, validation, and iteration locally changed the way we collaborate and foreshadowed the future of DevOps.

If you're running an open source project that requires loads of maintenance, you can't go wrong with Devin, not just as a tool, but as a new kind of team player, always ready to tackle those "long tail" tasks you can't be bothered with.

Devin is not a replacement for developers. It's about amplifying our ability to handle repetitive and monotonous tasks, allowing us to focus on what matters most. It's a productivity boost, a new perspective, and a way to move projects forward when resources are limited.

What this means for DevOps

Devin's ability to autonomously contribute, run local CI, and adapt to human feedback is more than just a cool feature-it's a glimpse into the future of software development. With the right protections in place, Devin can add a lot of value today; but in the long run, this technology could fundamentally change the developer-tool relationship, allowing us to build and deliver software in ways that were previously unimaginable.

We've involved Devin in contributing to a number of open source code repositories, including:

We're excited to see what Devin can do for your open source project! Visit app.devin.ai today to sign up, and register via the osi@cognition.ai Contact us to get your free quota for the team program!