Hi guys,

We have made Open Source Tool for the Programmers - Nexss Programmer.

50 different programming languages together...

If you guys want to check it out here is the link for the video presentation: https://www.youtube.com/watch?v=7WbnYyEnBNk

It would be great if we can get more feedback on it.

Have a nice day!

I would have already started attempting to do so except apparently I cannot see everything correctly with the "quick edit" app I downloaded. I want to edit the force of the steam I placed down in a custom level I made in stickman dismounting for a ludicrous amount of acceleration without a digital stroke inducing stack of em.

Links in the comments!

In the following, I’ll explain what this is, why I built it, and who it’s for:

BringYourAI is the essential bridge between your IDE and the web, finally making it practical to use any AI chat website as your primary coding assistant.

Forget tedious copy-pasting. A simple "@"-command lets you instantly inject any codebase context directly into the conversation, transforming any AI website into a seamless extension of your IDE.

Hand-pick only the most relevant context and get the best possible answer. Attach your local codebase (files, folders, snippets, file trees, problems), external knowledge (browser tabs, GitHub repos, library docs), and your own custom rules.

Why not just use IDE agents (like Cursor, Copilot, or Windsurf)?

IDE agents promote "vibe-coding." They are heavyweight, black-box tools that try to do everything for you, but this approach inevitably collapses. On any complex project, agents get lost. In a desperate attempt to understand your codebase, they start making endless, slow and expensive tool calls to read your files. Armed with this incomplete picture, they then try to change too much at once, introducing difficult-to-debug bugs and making your own codebase feel increasingly unfamiliar.

BringYourAI is different by design. It's a lightweight, non-agentic, non-invasive tool built on a simple principle: You are the expert on your code.

You know exactly what context the AI needs and you are the best person to verify its suggestions. Therefore, BringYourAI doesn't guess at context, and it never makes unsupervised changes to your code.

This tool isn't for everyone. If your AI agent already works great on your projects, or you prefer a hands-off, "vibe-coding" approach where you don't need to understand the code, then you've already found your workflow.

AI will likely be capable of full autonomy on any project someday, but it’s definitely not there yet.

Since this workflow doesn't rely on agentic features inside the IDE, the only tool it requires is a chat. This means you're free to use any AI chat on the web.

Then why not just use the built-in IDE chat (like Cursor, Copilot or Windsurf)?

There's a simple reason developers stick to IDE chats: sharing codebase context with a website has always been a nightmare. BringYourAI solves this fundamental problem. Now that AI chat websites can finally be considered a primary coding assistant, we can look at their powerful, often-overlooked advantages:

1. Dramatically better usage limits

Dedicated IDE subscriptions are often far more restrictive. With web chats, you get dramatically more for your money from the plans you might already have. Let's compare the total messages you get in a month with top-tier models on different subscriptions:

• Cursor Pro ($20): 500 o3 messages (based on the old Pro plan, as the rate limits for the new one are somewhat unclear).

• Windsurf Pro ($15): 500 o3 messages.

• GitHub Copilot Pro ($10): 900 o4-mini messages (Pro plan does not include o3).

Now, compare that to a single ChatGPT Plus subscription:

• ChatGPT Plus ($20): A massive, flexible pool including 600 o3 + 3000 o4-mini-high + 9000 o4-mini-medium + 25 deep research + essentially unlimited 4.1 or 4o messages.

The value is clear. This isn't just about getting slightly more. It's a fundamentally different tier of access. You can code with the best models without constantly worrying about restrictive limits, all while maximizing a subscription you likely already pay for.

2. Don't pay for what's free

Some models locked behind a paywall in your IDE are available for free on the web. The best current example is Gemini 2.5 Pro: while IDEs bundle it into their paid plans, Google AI Studio provides essentially unlimited access for free. BringYourAI lets you take advantage of these incredible offers.

3. Continue using the web features you love

With BringYourAI, you can continue using the polished, powerful features of the web interfaces that embedded IDE chats often lack or poorly imitate, such as: web search, chat histories, memory, projects, canvas, attachments, voice input, rules, code execution, thinking tools, thinking budgets, deep research and more.

4. The user interface

While UI ultimately comes down to personal taste, many find the official web platforms offer a cleaner, more intuitive experience than the custom IDE chat windows.

Then why not just use MCP?

First, not every AI chat website supports MCP. And even when one does, it still requires a chain of slow and expensive tool calls to first find the appropriate files and then read them. As the expert on your code, you already know what context the AI needs for any given question and can provide it directly, using BringYourAI, in a matter of seconds. In this type of workflow, getting context with MCP is actually a detour and not a shortcut.

I have seen tons of visual development tools in my career. Most of them were terrible. Some, like Webflow were pretty good, but very limited in scope.

In the mean time Game developers has been using tools like Unity and Unreal for 3 decades.

Why can't we have those kinds of tools, but designed for building web applications?

Personally, if you were to ask me, i'd probably say Galileo. I didn’t expect evaluation to be such a big part of my AI workflow, but once you start chaining tools or building with agents, stuff goes sideways real fast — and quietly.

Galileo’s been great for catching issues like hallucinations or agents choosing the wrong tool path — things that traditional testing or logging just don’t surface well.

Alongside that, I rely a lot on:

• Hugging Face for managing model experiments and fine-tunes — the hub is kind of my go-to place for sanity-checking baselines.

• Sentry (or something like it) for tracking real-time issues on the app side — not strictly "AI tooling" but absolutely essential once your LLM app has users.

The combo of observability + eval + model playgrounds covers most of what I need day-to-day.

Still figuring out the right level of automation in this ai world— curious what others are using for feedback loops, model QA, or whatever else you're thinking about from these ai tool world.

How many times have you dropped the same comment in a code review?

→ Don’t use new Date() directly, inject a Clock.
→ This code is duplicated.
→ We don’t use lodash here.

Feels like it’s 2025 and we’re still doing reviews on repeat mode.

That’s where one of the most used features in Kodus came from: Kody Rules.

Team rules, your way, right in the PR flow.

And the coolest part?

Kody learns from your team’s reviews.

She watches the comments you leave on PRs — and starts suggesting that stuff on her own next time.

No need to configure everything upfront, no model training.

I recorded a quick video showing one of the rules we use here:

→ “Avoid using new Date() directly in services. Inject the Clock.”

Simple, but it solves annoying bugs, kills off repetitive back-and-forth, and keeps things consistent without anyone needing to remember the rule.

If you could automate just ONE comment you keep repeating in reviews, what would it be?

No/low code tools have a lot of potential for developers with their ability to save time on easy tasks, but if you've ever worked with them, you probably understand how that benefit is easily overshadowed by how limited they are.

That's what we were thinking when we built Divhunt - a (very fast) site builder made to give you all the efficiency benefits of no-code tools like Webflow, while also being completely open for third party plugins, your own code, and more.

If you can code it, you can build it with Divhunt. Seriously.

Would love to get some feedback from more devs who try it out :)

https://habr.com/ru/post/458300/

You know that feeling when you need to push a commit after a long day and just can't come up with a good description for the changes so you end up typing some generic bs like "update UI"?

I know that feeling too well, SO just for fun I threw together a CLI tool that uses Ollama + the Gemma 3:1B model to generate Git commit messages from staged changes.

It’s fully offline and runs fast on local hardware. You just:

git add .
gemma-commit

It analyzes the git diff, generates a commit message, shows it, and asks for confirmation before running git commit.

There are also two other tools in the same repo as I'm trying out what local LLM's are capable of:

• clinky: converts natural language into actual macOS/Linux CLI commands

• gemma-parse-html: picks the best CSS selector from an HTML snippet based on a target (for scraping/debugging)

Repo’s here:
👉 https://github.com/otsoweckstrom/gemma_cli_tools

Definitely would need to train the model for actually accurate commit messages, but so far I'm surprised how well it performs.

Would love feedback if you try it. I'm mostly testing out how usable small local models like Gemma are in real workflows.

For ages now, we have been trying to fix the handoff process between designers and developers. The truth is it should never have existed in the first place.

Read the article here

for example vscode, intelij doesn't have an associated filetype so I can't double click anything to open a project. I would associate a filetype to the tool e.g. .vscode, or .android for android studio. And the tool will simply issue the command to open the IDE in the expected folder.

Starter code for anyone that's interesting in developing it further:

#!/usr/bin/env python3
import subprocess


import sys
import os
import shutil

def get_extension(name):
    name = name.replace("\\", "/")
    last_slash = name.rfind("/")
    last_dot = name.rfind(".")
    if last_slash >= last_dot:
        return None
    return name[last_dot+1:]

def spawn(*args):
    args = list(args)
    command = args[0]
    command = shutil.which(command)
    print("openning {} {}".format(command, " ".join(args)))
    return os.spawnv(os.P_NOWAIT, command, args)

def install_ubuntu():
    path = os.environ["HOME"];
    path = os.path.join(path, ".local/share/applications/project-open.desktop")
    with open(path, "w") as output:
        output.write("""[Desktop Entry]
Name=Project Open
Comment=Open applications that require folders
Exec={} %u
Icon=steam
Terminal=false
Type=Application
Categories=Utility;TextEditor;Development;IDE;
""".format(os.path.abspath(__file__).replace(" ", "\\ ")))


def main(args):
    if len(args) == 0:
        return 0

    if args[0] == "--install":
        return install_ubuntu()
    

    ext = get_extension(args[0])
    open_dir = os.path.dirname(args[0])
    if not open_dir:
        open_dir = "./"

    if ext == "vscode":
        spawn("code", open_dir)
        return 0
    return 1

if __name__ == "__main__":
    exit_code = main(sys.argv[1:])
    exit(exit_code)

I am looking for a powerful pdf editor to edit computer science and programming books. I need the pdf editor that capable of editing and adding new code blocks. I am using Adobe Acrobat DC and Inkspace neither of these programs sufficient.