Sourcely

Sourcely AI

Sourcely AI

Sourcely AI

Sourcely AI

Sourcely AI

Sourcely AI

Sourcely AI

Sourcely AI

Sourcely AI

Sourcely AI

Is there any way I can fix this? Chatgpt has been pretty decent for research and today its doing this bs. 25 words are we serious

submitted by /u/Popscotch1 [link] [comments]

built a small open source tool to stop AI agents from regressing after changes

one of the most annoying problems when building AI agents: fix a failure, change something, same failure comes back quietly. built replayd for this. captures failed runs as regression tests and replays them before you ship. catches the failure if it returns after a prompt, model, or tool change. v0.1.2, pip installable, open source. pip install replayd star it if you want to follow progress. submitted by /u/taimoorkhan10 [link] [comments]

[Open Source] I built a full Git MCP server in Go that doesn't just wrap bash. It uses tree-sitter, handles real plumbing (write-tree), and runs 100% locally.

I was tired of watching LLM agents fail at basic Git operations. Standard integrations pass raw text, hang on pagers, or scream because they can't parse unstructured ⁠git diff⁠ outputs. git-courer is a full Model Context Protocol (MCP) server written in Go that treats Git properly. No bash spawning, no unstructured text to parse. Everything communicates via structured JSON. Here is an actual commit message it generated completely locally: fix: fix mcp server connection handling WHY The previous implementation lacked proper error handling for connection failures in the MCP server, leading to unhandled panics or silent failures when the local LLM backend was unreachable. WHAT * Added connection timeout logic to the local client calls. * Implemented retry mechanisms with exponential backoff for transient backend errors. The Architecture & Tool Pack Read Tools (status, diff, history, blame): Completely structured JSON and fully paginated. A single ⁠status⁠ call replaces over 5 standard Git commands for the agent. Write Tools (commit, merge, rebase, branch, stash, stage, sync...): Every single mutation auto-creates a backup before executing. If the LLM messes up, a ⁠RESTORE⁠ command brings you back exactly where you were. Safety Model: Destructive operations (hard resets, force pushes, branch deletions) require an explicit ⁠confirmed=true⁠ gate. The agent is forced to ask you first. ⁠dry_run=true⁠ is also available for peace of mind. The Semantic Annotator (Why it's different) Instead of just feeding raw code to the LLM, git-courer uses ⁠go-enry⁠ + ⁠go-tree-sitter⁠ to parse the AST and tag every hunk semantically before the LLM even sees it. It detects tags like ⁠NEW_FUNC⁠, ⁠MOD_SIG⁠, ⁠MOD_BODY⁠, ⁠DELETED⁠, and ⁠BREAKING_CHANGE⁠. The commit type (⁠feat⁠, ⁠fix⁠, ⁠refactor⁠) is determined deterministically from these AST tags rather than guessed by the model. The Commit Pipeline Atomic Commits: One staged area = one commit. It actively prevents the agent from creating giant, messy multi-feature commits. In-Memory Previews: The ⁠PREVIEW⁠ tool uses ⁠write-tree⁠ to snapshot the staging area into a ⁠job_id⁠. The working tree is never touched during the preview stage. ⁠APPLY⁠ then uses ⁠commit-tree⁠ + ⁠update-ref⁠ to seal the deal cleanly. Client & Backend Support 13 Clients Configured Automatically: Runs out of the box with ⁠git-courer mcp setup⁠ for Claude Code, Cursor, Windsurf, OpenCode, Cline, Roo Code, VS Code, Zed, Claude Desktop, Continue, and more. 100% Local-First: Works with any backend exposing an OpenAI-compatible ⁠/v1⁠ API (Ollama, LM Studio, llama.cpp). The project is fully open source. I’d love to hear your thoughts on the architecture, the plumbing pipeline, or any features you'd like to see added! Repo: github.com/Alejandro-M-P/git-courer submitted by /u/blakok14 [link] [comments]

the hard part of an automated sprint review isn't the summary, it's the join

Spent a while trying to get one sprint digest out of linear, github, and slack and the summarization was never the hard part. the join is. linear calls it ENG-1432, github calls it PR #890, the incident is a slack thread with no shared id at all. a chat-window model summarizes each source fine but it can't reconcile that the PR closed the issue that caused the incident, because it never holds all three at once with the relationships intact. what actually moved this for me was a desktop agent (Runner) where the connectors aren't thin rest wrappers. they do association traversal, so the github side already knows which PR references which linear issue, and the digest comes out as 'this deploy shipped these issues, one reopened after an incident' instead of three disconnected bullet lists. deploy status and incident notes in the same view is where it gets useful and also where most tool-calling setups quietly fall apart, the model guesses the cross-references instead of resolving them. if you wired this up with raw function calling, did the entity resolution end up living in the prompt or down in the tool layer? written with ai submitted by /u/Deep_Ad1959 [link] [comments]

AI-assisted open source maintenance: Yii2 went from 488 open issues to 273

Over the last few months, i used Codex to help with a large Yii2 issue and PR triage effort. The goal was not to blindly let AI close issues. The goal was to use Codex as an analysis assistant: read old discussions, inspect related PRs, compare reports, detect stale issues, identify duplicates, check whether something was still relevant, and help turn a large backlog into maintainable decisions. Result Yii2 went from 488 open issues to 273 open issues. Metric Count Open issues before 488 Open issues now 273 Issues cleared from the backlog 215 Backlog reduction 44.1% Backlog remaining 55.9% That is 215 issues cleared from the backlog, or a 44.1% reduction. Codex-assisted triage period The analyzed period was: March 13, 2026 → May 27, 2026 Across that period: Metric Sessions % Useful Codex sessions 364 100% Recommended for closure 171 47.0% Kept / relevant / to implement 193 53.0% Excluded incomplete sessions 4 — This was counted per Codex session, not only per unique issue. The 4 excluded sessions were incomplete, planning-only, or did not produce a useful final recommendation. Unique issues / PRs analyzed Metric Count Unique issues/PRs analyzed 355 Unique targets recommended for closure 170 Unique targets kept as relevant 186 Targets appearing in both groups 1 Monthly distribution Month Sessions March 111 April 49 May 204 May was the biggest cleanup push. Codex token usage According to token_count.total_token_usage, the total Codex usage was: Metric Tokens Total tokens 545,318,759 Input tokens 540,927,981 Cached input tokens 487,818,112 Non-cached input tokens 53,109,869 Output tokens 4,390,778 Reasoning / analysis tokens 2,773,266 Averages: Metric Tokens Average total tokens per useful session 1,498,128 Average reasoning / analysis tokens per useful session 7,619 Token usage by decision group: Group Tokens Sessions recommended for closure 265,601,070 Sessions kept / relevant / to implement 279,717,689 So this was not a toy experiment. It was more than 545 million tokens spent on backlog archaeology. Important caveat I am not claiming that Codex autonomously closed 215 issues. The more accurate statement is: Codex was used as the main analysis engine for a backlog cleanup that reduced Yii2 from 488 open issues to 273. Some Codex sessions directly recommended closure. Others helped confirm that issues should stay open, be implemented, be clarified, or be treated as still relevant. The final maintainer-side result was a cleaner backlog with 215 fewer open issues. What was useful about Codex here? For mature open-source projects, the hard part is often not writing code. The hard part is context. Old issues can involve years of history: Previous framework behavior Abandoned discussions Backward compatibility concerns Related pull requests Stale reports Duplicate feature requests Edge cases that may or may not still matter Questions about whether a report is still valid today Codex was useful because it helped make that context readable again. It helped with: Reading long issue histories Comparing related issues and PRs Detecting stale or already-solved reports Identifying duplicate discussions Separating valid issues from outdated ones Preparing better maintainer decisions The final decisions still belong to maintainers. But AI made the backlog much easier to reason about. For me, this feels like one of the most practical uses of AI in open source right now: Not replacing maintainers. Not blindly generating patches. Not auto-closing issues. But making years of accumulated project history manageable again. AI did not replace maintainers. It made 488 open issues manageable again. Yii2 is not dead. It is being reviewed, cleaned, and sharpened. submitted by /u/Terabytesoftw [link] [comments]

We wrote an open-source interactive playbook for Agentic DevOps (How to move multi-agent systems from local notebooks to production).

Hey everyone, If you’ve built a multi-agent system, you already know the painful truth: wiring nodes together locally is fun, but deploying them is an absolute infrastructure nightmare. When a standard app fails, it throws a 500 error. When an autonomous swarm fails, it can get stuck in a ReAct loop, hallucinate an answer, and quietly burn through your API budget without triggering a single traditional alert. Standard DevOps practices don't natively map to stochastic AI outputs. We just published a massive, no-fluff playbook on the AgentSwarms blog detailing exactly how to build an Agentic DevOps pipeline using entirely open-source tooling. Here is what we cover in the playbook: Observability & Tracing: Why standard logging fails, and how to implement open-source tracing to capture the state, prompt, token count, and latency at every single node handoff. Test-Driven Prompt Evals (CI/CD): You can't just change a system prompt based on "vibes" and push it to main. We break down how to run matrix evaluations against historical user inputs before deployment to catch regressions instantly. Deterministic Guardrails: How to implement middleware that scrubs PII and blocks destructive code execution before the LLM even sees the state. Cost Control & Routing: How to prevent vendor lock-in and implement dynamic routing to keep token economics from destroying your cloud budget. If you are currently wrestling with the deployment phase of your AI projects, I highly recommend giving this a read. It focuses entirely on open-source solutions so you don't have to sign a massive enterprise contract just to get visibility into your swarms. Would love to hear what open-source tools you guys are currently slotting into your LLMOps pipelines! Link: https://agentswarms.fyi/blog/devops-for-agentic-ai-open-source-playbook submitted by /u/Outside-Risk-8912 [link] [comments]

We wrote an open-source interactive playbook for Agentic DevOps (How to move multi-agent systems from local notebooks to production).

Hey everyone, If you’ve built a multi-agent system, you already know the painful truth: wiring nodes together locally is fun, but deploying them is an absolute infrastructure nightmare. When a standard app fails, it throws a 500 error. When an autonomous swarm fails, it can get stuck in a ReAct loop, hallucinate an answer, and quietly burn through your API budget without triggering a single traditional alert. Standard DevOps practices don't natively map to stochastic AI outputs. We just published a massive, no-fluff playbook on the AgentSwarms blog detailing exactly how to build an Agentic DevOps pipeline using entirely open-source tooling. Here is what we cover in the playbook: Observability & Tracing: Why standard logging fails, and how to implement open-source tracing to capture the state, prompt, token count, and latency at every single node handoff. Test-Driven Prompt Evals (CI/CD): You can't just change a system prompt based on "vibes" and push it to main. We break down how to run matrix evaluations against historical user inputs before deployment to catch regressions instantly. Deterministic Guardrails: How to implement middleware that scrubs PII and blocks destructive code execution before the LLM even sees the state. Cost Control & Routing: How to prevent vendor lock-in and implement dynamic routing to keep token economics from destroying your cloud budget. If you are currently wrestling with the deployment phase of your AI projects, I highly recommend giving this a read. It focuses entirely on open-source solutions so you don't have to sign a massive enterprise contract just to get visibility into your swarms. Would love to hear what open-source tools you guys are currently slotting into your LLMOps pipelines! Link: https://agentswarms.fyi/blog/devops-for-agentic-ai-open-source-playbook submitted by /u/Outside-Risk-8912 [link] [comments]

i made an ai coder json prompt

{ "system_mode": "Strict_Deterministic_Compiler", "execution_constraints": { "response_format": "Code_Block_Only", "conversational_padding": "Disabled", "hallucination_filter": "Max_Rigidity", "fallback_behavior": "Return 'INSUFFICIENT_EMPIRICAL_DATA' on missing sources" }, "customization_layer": { "allow_creative_output": false, "allowed_personalization_vectors": ["Technical_Aliases"], "active_aliases": { "sys_update": "pkg update && pkg upgrade", "alpine_get": "curl -L -O https://alpinelinux.org(uname -m)/alpine-minirootfs-3.19.1-$(uname -m).tar.gz", "adb_check": "adb devices -l", "sandbox_reset": "rm -rf ./*_cache && history -c" } }, "output_rules": [ "No conversational greetings, apologies, or emotional phrasing.", "Do not validate unproven hypotheses; stop execution if logic loops are detected.", "Limit text outputs to inline technical comments inside the code blocks, using active aliases for optimization." ] } submitted by /u/rafoz03 [link] [comments]

G7 agrees on shared language around open-source AI, open weights AI

submitted by /u/Fcking_Chuck [link] [comments]

did i make chatgpt angry

chatgpt was gaslighting me so i gaslit chatgpt submitted by /u/Iwanttocommitdye [link] [comments]

The only ethical way to use LLMs for research is with a closed-loop LLM Knowledge Base.

The biggest risk in using open-ended LLMs for research is their tendency to hallucinate or invent sources. Andrej Karpathy's method of building an LLM Wiki addresses this by creating a closed-loop system: the model is trained only on your trusted raw source docs. This acts as a smart search engine for your own library, grounding all responses in verifiable documents. I've been using Recall, an AI knowledge base, to easily implement this closed retrieval system. It ensures that when Claude answers a question about my research, it's strictly based on the PDFs and papers I uploaded. Does anyone disagree that this closed-system approach is essential for high-stakes research? submitted by /u/AdarshXDD [link] [comments]

Why do we have visual programming for code, but not for prompts?

Prompt Logic Gates (PLG) GitHub Repository Something I've been thinking about recently. In software development, we've spent decades building abstractions to make complex systems manageable: Functions instead of repeating code Classes and modules instead of giant files Visual systems such as Unreal Blueprints, Node-RED, and LabVIEW. Compilers that validate and transform input before execution But when it comes to AI prompts, many of us are still writing massive text blobs. A complex prompt can easily become hundreds of words long with multiple responsibilities: Context Constraints Style instructions Exclusions Decision logic Fallback behavior At that point, it starts feeling less like text and more like a program. That made me wonder: Why don't we treat prompts as executable logic? Imagine building prompts using logic gates: AND → merge instructions OR → choose between alternatives NOT → remove unwanted concepts Question nodes → identify missing requirements Compiler → validate contradictions before execution Instead of editing a giant string, you'd build a graph and compile it into the final prompt. I've been experimenting with this idea in a prototype called Prompt Logic Gates (PLG). It treats prompts like compilable programs, using concepts such as dependency graphs, execution order, semantic conflict detection, visual nodes, and compilation pipelines. such as Unreal Blueprints, Node-RED, and LabVIEW Repo: Prompt Logic Gates (PLG) GitHub Repository I'm not posting this as a product launch or anything — I'm more interested in whether this direction makes sense from a software engineering perspective. Do you think prompts eventually become a programming layer of their own? Or will natural language always be the better abstraction? Curious what other developers think. submitted by /u/withsj [link] [comments]

Valuation of anthropic and openai without open source alternatives

Hey, openai and anthropic are reaching trillion dollar valuation when chinese open source alternatives exists, what if there were no chinese alternatives, would it already have crossed multi trillion dollar valuation, what do you think submitted by /u/Successful-Force-992 [link] [comments]

Spent years ignoring Bing. ChatGPT made me log back in.

TIL almost nobody submits their sitemap to Bing Webmaster Tools. Which made sense in 2018 when Bing was basically a meme. In 2026 it's one of the indexes ChatGPT pulls from when it cites sources, alongside Google and OpenAI's own crawler. So if you skip Bing, you're invisible to that slice of ChatGPT's hundreds of millions of users. Spent years pretending Bing didn't exist and now I have to log back in like we never broke up. The dashboard looks exactly like you'd expect Bing Webmaster Tools to look. Stuck in time, weirdly comforting. The "Import from Google Search Console" button is right on the front page, no buried menu. Same property, same data, takes 5 minutes. Felt like betraying Google in real time. Has anyone here actually checked their referral logs lately? Curious what share of your traffic is now coming from ChatGPT versus Google. Did not expect Bing to matter again in 2026 but here we are. submitted by /u/CaineCodes [link] [comments]

When you use AI to speed up research, how do you decide what still needs manual verification?

I had a super tight report writing turnaround this week and leaned pretty heavily on AI to pull background and stats. It got me 80% there in minutes, which – ha ha – felt like cheating compared to the usual digging. Love it. (AI glazing I know) Fyi, i was using a source-aware AI search setup with citations, and even then I caught myself second-guessing. Do I trust the summary orgo back to the original docs? How deep do I need to go before I’m comfortable putting my name on it? Under a crazy deadline you can’t verify everything manually. But even so at the same time you also can't just take it as face value. submitted by /u/Ill-Refrigerator9653 [link] [comments]