

This week's AI updates are all about making life easier for developers working with agentic tools. **Cline**, formerly known as Claude Dev, just dropped its v2.0.0 update with faster response times and real-time interactions, perfect for streamlining workflows. **OpenAI’s Realtime API** is a game-changer for real-time function chaining and voice-based coding with Ada. And finally, **Aider’s Architect/Editor** split simplifies complex code reasoning, making pair programming smoother than ever. 

## [Cline - (prev. Claude Dev)](https://github.com/cline/cline)

The new **Cline v2.0.0** update is packed with cool upgrades. First off, "**Claude Dev**" has been rebranded as **Cline**, and it now works faster across different models. You get **real-time responses** streamed right into your editor, and there's a cancel button so you can stop things if **Cline** heads in the wrong direction. They also switched to using XML tags for tool interactions, which cuts down on requests by 40%, making everything smoother. Another, you can search and use any **OpenRouter** model easily, and the project now runs under the Apache 2.0 license.

![](assets/digest-01-cline-benchmark.webp)

## [Realtime API with o1 assistant](https://www.youtube.com/watch?v=vN0t-kcPOXo)

We founded it [github repository](https://github.com/disler/poc-realtime-ai-assistant) 2 week ago. The speaker talks about [**real-time APIs** provide by OpenAI](https://openai.com/index/introducing-the-realtime-api/) and the way communicate with **o1 assistant**. It's cool to see how OpenAI has made a game challenge for the coding assistant, letting software engineers now interact with LLMs using voice. Here are some key points from the talk:

- **Realtime API Features**: The speaker explains how this API makes **real-time tool chaining** and **function chaining** possible, allowing Ada to handle complex tasks with great accuracy.
- **Technical Insights**: They dive into how Ada uses different AI agents, with a focus on file management (CRUD operations) and testing out file-related AI agents.
- **Trade-offs and Risks**: The speaker also talks about the trade-offs with using the Realtime API, pointing out that while there are risks, the benefits for engineers and developers are huge. He encourages devs to jump on board to stay competitive.

![](assets/digest-01-openaI-realtime.webp)

## [Aider - separating code reasoning and editing](https://aider.chat/2024/09/26/architect.html)

**New approach from Aider:** 

- **Architect Role**: Generates a solution to the coding problem, focusing purely on reasoning. ( Use a strong reasoning model like o1-preview as your Architect. )
- **Editor Role**: Converts the Architect's solution into specific, well-formatted code edits. ( Use a cheaper, faster model like gpt-4o as your Editor. )
- **Performance test**: Using o1-preview as the Architect with either DeepSeek or o1-mini as the Editor produced the SOTA score of 85%. Sonnet, GPT-4o and GPT-4o-mini all scored higher when used as an Architect/Editor pair.

Aider's new "Architect/Editor" feature is inspired by OpenAI’s o1 models. Instead of struggling with perfect code edits, it lets the LLM describe the solution freely, then passes that to a second LLM to generate code updates. This way, it's faster and smoother, making complex sources code easier to handle while still keeping that interactive, pair-programming feel.

```bash
pip install -U aider-chat

# Change directory into a git repo
cd /to/your/git/repo

# Work with Claude 3.5 Sonnet as the Architect and Editor
export ANTHROPIC_API_KEY=your-key-goes-here
aider --sonnet --architect

# Work with OpenAI models, using gpt-o1 as the Architect & gpt-4o-mini as the Editor 
export OPENAI_API_KEY=your-key-goes-here
aider --model openrouter/openai/o1-preview --architect --editor-model openrouter/openai/gpt-4o-mini
```

![](assets/digest-01-aider-benchamrk.webp)

Stay updated on the latest in AI tools for developers with this week’s digest, featuring Cline's v2.0.0 update, OpenAI’s Realtime API, and Aider’s Architect/Editor split for enhanced coding workflows.

AI digest #1 Aider reasoning, OpenAI Realtime API, Cline - pre Claude-dev 



## Aider v0.63.0 release

- Support for Qwen 2.5 Coder 32B.
- `/web` command just adds the page to the chat, without triggering an LLM response.

Qwen 2.5 Coder 32B has been making waves in the past week. This could be a turning point for self-hosting models for coding without needing to call a third-party API. Additionally, the new `/web` command allows developers to easily input a URL as documentation context for Aider.

Here's an example of how to use the `/web` command. The developer provides the documentation URL for initializing Langfuse, which is used to trace API calls for a wrapper.

![](assets/digest-02-web-command.webp)

## OpenHands

OpenHands just took a huge step forward with *All Hands Online (Beta)*, a new hosted version of its AI software development tool. This means no more wrestling with setup—just go to app.all-hands.dev, and you’re good to go in seconds! OpenHands has already proven itself by solving over half of real GitHub issues on the SWE-Bench Verified benchmark, and now it’s easier than ever to get started.

![](assets/digest-02-new-ui-openhand.webp)

The hosted version also comes with a fresh, redesigned interface and smooth GitHub integration. With the GitHub integration, you can hook up your repos directly, clone projects, and push changes right from OpenHands, keeping everything in one place. And this is just the beginning—more features are on the way to make the tool even smarter, more customizable, and ready to tackle bigger challenges.

![](assets//digest-02-github-integrated-openhand.webp)

## Qwen2.5 Coder 32B

The Qwen team is excited to announce the open-source release of the Qwen2.5-Coder series, a set of highly capable AI coding models designed for practical, real-world programming tasks. Headlining the series is the Qwen2.5-Coder-32B-Instruct, which has set a new standard as the top open-source code model, rivaling the performance of commercial models like GPT-4o. With six model sizes ranging from 0.5B to 32B, Qwen2.5-Coder meets diverse developer needs, whether for lightweight tasks or complex code generation. The models excel in coding benchmarks like EvalPlus and BigCodeBench, offering robust performance across over 40 programming languages, making it a flexiable assistant for a wide range of coding needs.

![](assets/digest-02-qwen-bench-1.webp)

In addition to coding and code repair, Qwen2.5-Coder also demonstrates strengths in code reasoning and multi-language support, with impressive scores on benchmarks such as McEval and MdEval. This release is a big win for open-source developers who want a powerful, accessible alternative to proprietary models for code generation, repair, and reasoning tasks. Qwen2.5-Coder is also licensed under Apache 2.0, ensuring flexibility and ease of use. The team is looking forward to expanding its capabilities, exploring advanced reasoning models, and unlocking new possibilities in collaboration with the coding community.

![](assets/digest-02-qwen-bench-2.webp)

## Predicted outputs - OpenAI

Predicted Outputs let you speed up model responses by giving the model a heads-up about parts of the response you know won’t change. This is super handy when you’re making small edits to code or text since most of it stays the same. You just pass the existing content as a "prediction" to the model, and it can skip regenerating what it already knows.

For example, say you have a function that logs messages, and you want to tweak it to include the current date. Instead of rewriting the whole thing, you send the original function as a prediction. The model then quickly returns just the updated version, where it logs both the date and the message, saving time and effort.

### Original Code

```jsx
function logMessage(message) {
  console.log("Log:", message);
}

export default logMessage;
```

### Prediction Setup and Code Update Prompt

In this case, we want to modify the `logMessage` function to include the date. Here’s how you’d set up the request with a `Predicted Output`:

```jsx
import OpenAI from "openai";

const code = `
function logMessage(message) {
  console.log("Log:", message);
}

export default logMessage;
`.trim();

const openai = new OpenAI();

const updatePrompt = `
Modify the logMessage function to log the current date and the message.
Return only the code.
`;

const completion = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [
    { role: "user", content: updatePrompt },
    { role: "user", content: code }
  ],
  prediction: {
    type: "content",
    content: code
  }
});

// Inspect the response
console.log(completion.choices[0].message.content);
```

### Expected Response

The model will likely return the following:

```jsx
function logMessage(message) {
  const date = new Date().toLocaleString();
  console.log("Log:", date, message);
}

export default logMessage;
```

In this example:

- `Predicted Outputs` speed up the response by leveraging the known structure of the original function.
- The only change made is the addition of the date logging, saving on both response time and computational resources for minor modifications.

Using predictions helps accelerate similar tasks, particularly when refactoring or adding minor updates to existing code or text documents.

## Reference

- https://aider.chat/HISTORY.html
- https://qwenlm.github.io/blog/qwen2.5-coder-family/
- https://www.all-hands.dev/blog/announcing-all-hands-online-beta
- https://platform.openai.com/docs/guides/predicted-outputs

Stay updated on the latest in AI tools for developers with this week’s digest, new command Aider, OpenHands, Qwen2.5 Coder 32B

Playground > Ai > Digest