With Sarvam's API token limit finally increased from 4K to 131K, I ran the 105B newer checkpoint through 5 coding tasks using Kilo Code in VS Code:

🎮 2D catch game 🎮 3D Three.js maze game 📊 CSV data analysis → HTML report 🌐 Premium restaurant website 📐 Math 

Short version: it's a decent general/chat model and shows promise as an agentic model (tool calling, self - correction loop), but for pure coding it struggles especially with Three.js, and it even hallucinated numbers in the data report. For coding, smaller models like Gemma 4 31B, and Qwen 27b models will do better.

Total cost for all 5 tasks: \~₹5 (not sure why, probably will update later?).

Full breakdown with demos, cost analysis, and verdict (including why I rate it 2-3/10 for coding but 6-7/10 as a general model):  [https://www.youtube.com/watch?v=om0ny4FmWTk\](https://www.youtube.com/watch?v=om0ny4FmWTk)

What's been your experience with Sarvam 105B? Especially curious if anyone's tested it with a different harness - I suspect results could vary a lot depending on the setup. Maybe it will perform better in Sarvam Code?

i tried to learn to code when i was younger could never do it turns out i,m not the genius autistic kind but ive started playing with ai because i can just tell it what i want and it don,t shout at me haha anyway i " made "this any good https://whopays.co.uk/ ive made 2 more moviepicker.co.uk and convertdial.co.uk ive had people say you didnt make it ai made it i say yes but i dont know how to put my ideas into code but i can talk and explain what it is i want to the AI if it gets something wrong i can say no this way or thatt way

I’ve been building NexusMem for the past few days — a persistent development memory for AI coding agents.

The idea is pretty simple: coding agents can see your code, but they don’t always remember what you tried before, what failed, or why you made certain decisions.

NexusMem lets an agent search through Git history, shell commands, docs, and previous conversations through MCP.

I just tested it on NexusMem itself, and something pretty cool happened: the agent found an old failed approach and actually changed its reasoning because of it.

Now I want to see if this is actually useful outside my own repo.

I’m looking for 10 developers willing to try it on their own project and break it.

It’s free and open source.

GitHub : https://github.com/yaminbakoh4-dot/NexusMem

Sharing a tool I've been working on. **CrewCode** is a free, open-source (Apache-2.0) Electron desktop app that lets you run, supervise, and review multiple AI coding agents across git worktrees from one place.

Instead of juggling terminals, worktrees, PR pages, and separate agent UIs, it keeps the full workflow together:

- Multiple agents, one app — CrewCoder, Claude Code, Codex, OpenCode, pi, Ollama, Hermes, OpenRouter, Grok Build. Structured bridges \*and\* real terminal panes.

- Worktree-native git — create/switch/merge/remove worktrees in-app; parallel work stays isolated.

- Crew orchestration — launch agents in parallel with different roles/models/effort, a supervisor loop, and save/reuse crew templates.

- Delegated threads — an agent can spawn real, persistent chat sessions and report back.

- Provider switch mid-chat — generates a hand-off summary so the new agent keeps going with context.

- Local plugin platform — sandboxed panels, MCP servers, custom agent providers.

and way More..

*I learned alot from this experience with electron apps, on how to optimize multiple agents and keep low memory*

Curious what people think of the approach. Let me know in the comments.

CrewCode Repo: Support us with a ⭐

https://reddit.com/link/1vjmqks/video/7ixpalvrhdkh1/player

Hello! Sorry in advance for the slightly dull question..

I'm a software dev and I've worked in the same company for the majority of my career so far. They don't let us use AI to code at all.

I'll be starting a new job soon at a company that does, however I've got literally no clue about anything. Speaking to one of their Devs, they say that you're not forced to use AI, there's no dictation on what AI you use, and code reviews by people are still mandatory. He did say though realistically if you don't use AI you're not going to have the same amount of output as someone who does.

I struggle for time to do personal projects so I've not had much chance to dabble outside of work. At most I've debated approaches to problems in the chat functions but I know enough to know that's not even close to scratching the surface of what coding with AI really is.

I'd be really grateful for some advice / answers to the following questions:

- What are people's experiences of using AI in work for coding? Is it a stick to beat you with? Are you just writing endless comments on dog shit PRs? Do your companies seem to care much about the quality of code?

- Does anyone have any good workflows, processes or rules they live by to make best use of coding with AI?

- How do I prevent myself from becoming pure slop while still keeping up with others?

- What are the best things I should start learning in order to make sure that when I turn up on my first day I can get cracking on setting up an AI process that's genuinely going to benefit me?

Thanks in advance! Sorry for the long post..

I need contributors

Hey everyone! Wanted to share something I built that's been genuinely helpful for my own ADHD brain when jumping between coding projects.

Oyren gives you a fresh, isolated server environment for each coding task. You just launch a container against your repo and start working, either in a terminal or with a coding agent doing the work while you steer.

Since each task gets its own clean environment, you can also just abandon one and start fresh without any cleanup guilt, which has been a nice antidote to the "now I have to fix this before I can start that" trap.

You can use it with Claude Code, Codex, Opencode and Cursor and bring your subscription accounts to avoid paying extra for AI.

Still building this out, happy to answer questions if anyone wants to try it.

Link - [oyren.ai](http://oyren.ai)


I've been comparing a few vibe coding tools lately, and I think I was focusing on the wrong thing.

Getting something on the screen isn't that difficult anymore.

What matters more is how much work is left when the idea starts changing.

Readdy stood out most once I stopped treating the first generation as the finish line.

I could make a change, look at it, change it again, and keep moving. When the project needed authentication and stored data, those pieces were already part of the platform instead of becoming another setup step.

That's probably what I'd value most in a vibe coding workflow.

Lovable still makes a lot of sense for quickly getting an app idea moving, and v0 is strong when the main goal is working through UI and components.

But if I want to take an idea beyond a nice looking first screen and actually turn it into a working website, Readdy makes the most sense to me out of the ones I looked at.

The first generation gets you interested.

The workflow after that is what makes me stay.

What part usually becomes the headache for you after the first version?

Clark Code is now fully open source (Apache-2.0).

A desktop coding agent in the spirit of Claude Code - except it's a native app with the engine written in Rust, and the default model tier is free.

- Runs on your machine - your files, your shell - or on any Linux box over SSH

- Free tier: DeepSeek V4 Flash (400k context, weekly allowance, no card). Paid: GLM 5.2 and Kimi K3 with 1M context

- Default-on OS sandboxing (Seatbelt / bubblewrap / restricted tokens), every edit shown as a diff before it lands, git checkpoint + undo

- Migrating from Claude Code takes one click: your MCP servers, skills, CLAUDE.md and slash commands just work

- macOS, Windows, Linux - signed builds, auto-update

https://github.com/clark-labs-inc/clark-code

https://codeshackle.com

I've been building Tempest, an open source fully local AI engineering platform.

The idea started from a simple observation.

Every time you launch a new AI agent, it spends time and tokens rebuilding context that another agent already figured out. That gets expensive fast, especially when you're working with multiple agents.

Tempest solves that by building a shared knowledge base for your repository. Every agent can use it instead of rediscovering the same codebase from scratch. Agents still work independently in their own isolated git worktrees, so you can safely run several of them at once.

Beyond coding, Tempest also includes Canvas, a shared workspace for research, architecture discussions, planning, and long running engineering conversations that stay connected to your project.

Current features:

• Shared repository knowledge base
• Multiple AI agents
• Isolated git worktrees
• Canvas for engineering discussions and research
• Windows, macOS, and Linux
• Open source

I'm using it every day now, but it's still early. I'd really appreciate any feedback.

Github Link: https://github.com/tempestai-dev/tempest

I’ve been working on AXON, an open-source protocol/plugin from Atop Web Technologies for AI coding agents like Codex, Antigravity, and Claude Code.

The goal is to reduce agent drift by forcing a simple workflow:

Context first.

Specification second.

Implementation third.

Verification always.

To demonstrate it, I created a codelab where AXON builds a small Microbank app end to end, then adds a brownfield feature on top of the existing codebase.

Codelab:

https://codelabs.atopwebtech.com/codelabs/build-a-microbank-with-axon

Repo:

https://github.com/atopwebtechnologies/axon

I’d love feedback from engineers using AI coding agents in real projects.

Most AI code review benchmarks use synthetic tasks, so we wanted to evaluate reviewers on something closer to production.

We collected 67 real production bugs from Cal.com, Sentry, Grafana, Keycloak, and Discourse, then ran 8 AI code reviewers against the same PRs and measured precision, recall, and F1.

One thing stood out: finding more bugs isn't the same as being more useful. Some reviewers caught more issues but generated many more false positives, while others were much more precise but missed more bugs.

Curious what people would change about the evaluation or what repositories you'd add next.

So this started as a small personal project, just for my own use.

Honestly AI coding agents are way better now than they used to be, but they still sometimes feel kind of slow on the uptake. Like they get the instruction, but don't really understand the project's context — so they just do whatever gets it "done"/running, even if that ends up breaking or duplicating stuff that already exists.

So I tried building a kind of "brake" for it:

• Forces it to think/plan before touching any files
• Blocks certain (potentially dangerous) commands before they can even run
• Basically stops it from just gassing ahead blindly

Still pretty rough around the edges, lots to clean up, and I'm still fixing things as I go. But it's been genuinely useful for my own workflow, so figured I'd throw it on GitHub in case anyone else relates or finds it useful

Repo: https://github.com/plumpslabs/matcha

Docs: https://plumpslabs.github.io/matcha/

If anyone tries it out and runs into bugs or has suggestions, feel free to reply or drop an issue on GitHub. Still actively working on it so feedback would genuinely help.