Hello! 👋

We launched a free and open-source project for developers: DevGlobe 🌍

The idea: while you're coding, you appear on a globe so you can:

• Track your coding stats (per repo, per file, per branch, per language) with real insights into your patterns
• List your projects (open source, side projects, or startups)
• Build a public dev profile (stats + projects + activity, ready to share like this)
• Motivate yourself to code (goals, badges, private leaderboards with friends)

Already using WakaTime? The endpoint is WakaTime-Compatible, just point your existing client at it and you'll appear on the globe with no new extension needed.

Privacy first:

• Anonymous mode → a random city in your country
• Standard mode → only your city is shown (never your exact location)
• Private mode → completely off the globe (if you just want the stats, goals, leaderboards, or to showcase your projects)

100% free

100% open source

Your personal data and your code are never sent to the backend

🌍 The Globe: https://devglobe.xyz/space

💻 Source code: https://github.com/Nako0/devglobe-extension

📦 Marketplace: https://marketplace.visualstudio.com/items?itemName=DevGlobe.devglobe

If you are interested or have any questions, everything is explained on the website, but don't hesitate to ask, I will be happy to answer your questions!

After fixing more than 90 bugs, I can now safely claim that my project when downloaded from npm or built from source is stable. As a newer dev there was a LOT of issues I had to work through, hours of troubleshooting and tui/commandline conflicts. It was a nightmare but it's finally over.
I would really appreciate if new users or those that had a bad experience could give it another shot.
https://github.com/Doorman11991/smallcode
over 50 people have made forks of my project, I hope everyone can take my code and use their own inspiration to make it 100x better.
I appreciate all of your support and kind words over the last few days. Thank you!

I was facing problems with adding safety hooks for iOS and Android app submission as they were getting rejected. So, I built an app compliance auditor. https://github.com/atharvnaik1/ipaship-audit

But later on I thought ohh!! Why not create a cli tool, claude skill (ipaship-audit) and a mcp connector which can make every person's llm with safety hooks not just for apps but for every code its written.

You can access it at \~ npm i @async-atharv/ipaship

I have also added kimi and gemini keys with default options.

This audit for secure code, appstore policy compliance, bug fixes and give back REMEDIATION PLAN to your llm agent itself and your llm agent can work on it rapidly on that prompt itself. So no more leaving your IDE or claude code all things handled within the environment you loved 😍 !! ..

Today it instruments CyxCode’s process and filesystem wrappers, records shell/file/network-style events with session

and prompt context, scores risky activity, writes local JSONL audit logs, and exposes dashboard/report APIs.

Destructive shell commands are blocked before spawn, and sensitive writes/risky actions are classified for policy

decisions.

None of the major coding CLIs have this. Not Claude Code, not Cursor, not Windsurf, not Aider. They're all trust-and-hope.

CyxCode is open source fork from opencode and the repo is live. If this is a problem you've thought about too, I'd really appreciate a star — it helps signal that runtime AI transparency is worth building properly.

https://github.com/code3hr/cyxcode

The question: What is the practical agentic framework to use to make the agents run until job is done without reporting to me prematurely?

My goal: Actually fully spend a $200 codex subscription, but make it be well spent.

I'm interested in what is practically optimal to use today. Not what someone imagines as a cool idea for the future or what some agent freestyled for a overly-optimistic README

Through my reddit search i found these ideas:

I'm not recommending any of the frameworks i mention there, it's just what i found:

I did some research on agentic frameworks.

I didn't get to try any of these yet. I genuinely don't know what is optimal but i assume it might be one of sandcastle/oh-my-opencode-slim/openspec

who tried any of these? which of one is best, or maybe someting else altogether?

github.com/code-yeongyu/oh-my-openagent - Allegedly, it uses a lot of tokens.

https://github.com/obra/superpowers - Allegedly, it uses a lot of tokens.

https://github.com/alvinunreal/oh-my-opencode-slim

https://github.com/mattpocock/sandcastle - more deterministic than agent-to-agent-talk afaik

https://github.com/gsd-build/get-shit-done

https://github.com/snarktank/ralph - is probably worse than sandcastle since mattpolock used to use ralph before he made sandcastle, afaik

https://github.com/bmad-code-org/BMAD-METHOD

https://github.com/Fission-AI/OpenSpec

deterministic (coded) agent harness - not agent-to-agent-talk. scripts controlling agent behaviour and his done status. tests determining if agent commences or retries.

personally i hoped to find some more deterministic framework around agents. just so that they are made sure to finish the tasks instead of leaving them hanging. Like a belief that what llms lack is some deterministic logic to control them.

But yet here are all those llm-to-llm orchestration systems. Afaik ony sandcastle is the one that is more determninistic of them.

3. grill-me-with-docs, generally also https://www.youtube.com/@mattpocockuk and his ideas like "say why you want what you want, not just what you want, so agent can suggest alternatives."

I found such repo shape, seems overblown, my first instinct is "oh nice so now its like 20 files all of which agent will fill with exact same content just with different wording, creating a huge repeating slop" but maybe some of these are good ideas to have

docs/

├── diagrams/ (can't show contents, names are revealing)

├── knowledge-base/ (can't show contents, names are revealing)

├── modes/

│ ├── ARCHITECTURE_BRIEF_TEMPLATE.md

│ ├── DOCUMENTATION.md

│ ├── FRONTEND.md

│ ├── GENERAL.md

│ ├── GRAPHQL.md

│ ├── PLANNING.md

│ ├── RAILS.md

│ ├── REVIEW.md

│ ├── TESTING.md

│ └── TOKEN_EFFICIENCY.md

├── project-intelligence/

│ ├── adr-index.md

│ ├── business-domain.md

│ ├── business-tech-bridge.md

│ ├── decisions-log.md

│ ├── living-notes.md

│ ├── management.md

│ ├── navigation.md

│ └── technical-domain.md

├── workflows/

│ ├── component-planning.md

│ ├── feature-breakdown.md

│ ├── session-management.md

│ ├── task-delegation-basics.md

│ └── task-delegation-specialists.md

├── INDEX.md

└── README_FOR_HUMANS.MD (explains the system for human engineers)

"say: Prioritize retrieval-led reasoning over pretrained-knowledge-led reasoning.

That is all. After receiving this instruction, the LLM will load the relevant Skill for a given coding scenario instead of falling back on its internal pretrained knowledge. From my testing, the Skill loading success rate jumps from around 60% to 90%."

btw i also found this fairly interesting guide on oh-my-opencode-slim + openspec if anyone is interested in those tools:

https://www.dataleadsfuture.com/how-i-use-opencode-oh-my-opencode-slim-and-openspec-to-build-my-own-ai-coding-environment/

I found information on LinkedIn today about the Qwen 3.7 Max preview. I haven't tested the 3.6 preview, but the 3.6 Plus version, while I was programming, is simply excellent!

I got along very well with Qwen 3.6 Plus.

Version 3.7 Plus is also being released.

Is anyone else satisfied with Alibaba's templates?

Qwen 3.7 Preview

After 6 mins in plan mode, planning and burning almost a Dollar it asked me a question, to which I answered, then says sorry I cant help you.. 😂

Vibe coding is basically the chaotic good route to actually understanding the stack.

You also accidentally learn:

Why your code works on your machine but nowhere else.

Grit. Reading an ijustvibecodedthis.com guide at 3am is not for the week.

That “it works in development” is a personality trait.

How to read 47 lines of cryptic error logs like it’s ancient scripture.

The difference between “should work” and “actually works in prod.”

That one random package is secretly carrying your entire app.

Vibe coding over forcing yourself to read docs for 6 hours straight.

The knowledge just sticks when you’re deep in the trenches at 2am.

Who else got baptized by fire this way?