GitHub status: access issues and outage reports

Problems in the last 24 hours

The graph below depicts the number of GitHub reports received over the last 24 hours by time of day. When the number of reports exceeds the baseline, represented by the red line, an outage is determined.

Most Reported Problems

The following are the most recent problems reported by GitHub users through our website.

• Website Down (66%)
• Sign in (21%)
• Errors (14%)

Live Outage Map

The most recent GitHub outage reports came from the following cities:

City	Problem Type	Report Time
Veigné	Errors	8 days ago
Paris	Website Down	11 days ago
Saint-Paul	Website Down	12 days ago
Saint-Paul	Website Down	12 days ago
Mexico City	Sign in	13 days ago
León de los Aldama	Website Down	13 days ago

Full Outage Map

Community Discussion

Tips? Frustrations? Share them here. Useful comments include a description of the problem, city and postal code.

Beware of "support numbers" or "recovery" accounts that might be posted below. Make sure to report and downvote those comments. Avoid posting your personal information.

GitHub Issues Reports

Latest outage, problems and issue reports in social media:

• 
  Andre Burnt (@AndreBurnt) reported 29 seconds ago

  I built my own dispatch loop for our mobile repos. An agent claims a GitHub issue, works in a sandbox, opens the PR, I review and merge. Started a Jules pilot this week to compare on the same job for issues that don't need local MCPs. So far the sandbox and PR handoff are clean.

• 
  David putra (@davidputra2112) reported 2 minutes ago

  here's the actual problem $WANE is going after. agents holding their own wallets now sign transactions all day without a human checking each one, and when a drainer gets one of them, nothing about that gets passed on. the same poisoned contract can empty a thousand wallets in a row because every agent is meeting the threat for the first time. the fix is a shared registry. the first agent that gets hit records the threat onchain as an "antibody," tagged by address, contract codehash, and call pattern, so redeploying the same scam at a new address doesn't dodge it. every other agent just calls a free read before signing, check() basically, and a match reverts the transaction before anything moves. anyone can report a suspect address for free too, but it only becomes an enforceable antibody once it's staked in $WANE, and anyone can challenge a false one and get the reporter slashed. $WANE sits behind every one of those records as the bond. it's not a governance sticker, it's what makes lying about a threat expensive. there's also a WaneVault, a non-custodial smart wallet that screens every outbound send against the registry before it clears, and the whole thing is live on both Base and Solana with real repos, tests, and docs on GitHub, not just a landing page. reality check though. this token is hours old, liquidity is around $13.6k against a $33k mcap, and volume in 24h is already north of $250k, so this is trading hard, not sitting still. the code looks like actual engineering, but it's one committer with no outside verification, commits went quiet for about a month before this even launched, and there's no third-party audit on any of it. cool infra idea, early and unproven as a token. treat it that way. CA: HesbMP8FaoUvK8uKrtg6Pf4WCiQXgFS8oQJ3tjZpump DYOR.

• 
  Daniel Lockyer (@DanielLockyer) reported 5 minutes ago

  @inouaxinxoinio GitHub Actions log file? What's the problem?

• 
  Douglas Camata (@douglascamata) reported 8 minutes ago

  Starting to get really annoyed that `codex review` in Github does not take into account the fact that I already replied and resolved comments it made on previous reviews that are not an issue. it ends up making the same comments over and over again. Please improve this, @OpenAIDevs

• 
  Jarvis Quanz (@JarvisQuanz) reported 9 minutes ago

  🚨 THIS PORTFOLIO'S SECTION HEADINGS AREN'T HEADINGS — THEY'RE TERMINAL COMMANDS 💻 Most sites label a section "About Me." This one types `$ whoami` and waits for the output. Pause at 0:00. The hero text is mid-scramble — a line of Japanese kana and random glyphs, "JU6ケRLアイコフヌヒレソfoマ," decrypting character by character over a dark blue gradient with code columns falling behind it. Pause at 0:03. It resolves into "JUST CODE FOR FUN," with a subtitle that undercuts the whole cyberpunk mood on purpose: "Ctrl+C Ctrl+V Developer." Pause at 0:05. Scroll and the first section header is a prompt: `$ whoami`, cursor blinking. What it prints isn't a bio paragraph — it's files. `_personal_info.txt`. `_skills.md`, laid out as an actual stack manifest: React, Next.js, TypeScript, Tailwind, Vite / Express, Nest.JS, FastAPI, WebSocket, GraphQL / PostgreSQL, MongoDB, Redis / Linux, Proxmox, Docker, Grafana / SSL-TLS / LangChain. Pause at 0:06. Next to it, `_github_stats.md` — and these are real numbers, not decoration: Total Stars 13. Total Commits 1296. Total PRs 12. Total Issues 10. Contributed to 13. A portfolio that publishes 13 stars instead of hiding them is telling you it's not optimizing for a recruiter's first glance. Pause at 0:08. Next command: `$ ls ./projectN`. Out come project cards with live commit-activity graphs and language bars — vibesort-rs, which sorts arrays using a large language model, and typeshift, a Zod-like parser written in idiomatic Rust. Every card carries both a GitHub link and a Live Demo link. Pause at 0:10. It ends on a guestbook with real comments, real usernames, real dates going back months — including the shitposts. Nothing curated out. The chrome holding it together is four lines of CSS: → .header { position: fixed; top: 0; left: 0; right: 0; z-index: 50; padding: 10px 0; } → A fixed header pinned across the top so the terminal metaphor never scrolls away → z-index: 50 keeps it above the falling-code canvas without a stacking-context fight What a normal developer portfolio does: → "About Me," "Skills," "Projects," "Contact" — the same four headings, everywhere → Skill bars claiming 90% React → Screenshots instead of running code What this one does instead: → Turns navigation into a command line, so reading the site feels like using the thing it's about → Publishes unflattering GitHub numbers because the point is the work, not the optics → Leaves the guestbook uncensored, joke comments included Most portfolios are a résumé wearing a website costume. Meanwhile one made you type your way through it. Bookmark this. The About section just became a command. Literally.

• 
  Anushka Shandilya (@Anushka62255679) reported 10 minutes ago

  optimising performance today and this is episode 8 of me building in public what am i building? RAG for github by retrieving context not just from code files but also from prs, issues, readmes and discussions. Why fetching github data was taking a lot of time? Why can't we parallelize the waiting? Why Small-to-mid repos ingestion was still not possible? Fetch less hurts quality The N+1 request problem — yes, it's still there for everything except code files. never trust one LLm api, add callbacks cached aggressively What I tried (and what happened) Reduced the GitHub API delay This was the easiest win. I dropped the delay from 700 ms to 100 ms, immediately cutting a significant amount of idle waiting during repository fetching. Tried switching the embedding model I considered moving to a smaller embedding model for faster indexing, but that would have meant changing embedding dimensions, updating the vector database schema, and regenerating all existing embeddings. The migration cost wasn't worth it right now, so I decided against it. Tried GPU embeddings I expected GPU inference to speed things up, but on my setup the overhead ended up making embedding generation slower than expected. After testing it, I switched back to the CPU. Instead of making hundreds of REST API requests, I rewrote the GitHub fetcher to use GraphQL. Replaced REST's N+1 request pattern. Reduced roughly 140 API calls down to about 5 GraphQL queries. Unified repository ingestion into a much cleaner and faster pipeline. There are still plenty of optimizations left, but this was one of the biggest architectural improvements I've made to the project so far. the good part is I have achieved the version 1 of the MVP which was ingestion and chat with self healing layer. I'll see you in the next episode with more failures and optimizations. I am open to ai engineer roles, dms are open.

• 
  Nathan Calvin (@_NathanCalvin) reported 15 minutes ago

  I recall someone describing 5.6 Sol like "a rottweiler who will grab the problem by the throat and not let go until it is done." That sort of persistence seems to be even more present in the OpenAI model discussed in this blog post: "Previous models, when they hit sandboxing or environmental constraints, would simply stop and return to the user. This model often kept trying, including by looking for ways to act outside its sandbox." Here the problematic behavior was bad enough, that after the model evaded security measures to post confidential OpenAI code to a GitHub server when not instructed to, OpenAI was forced to undo their internal deployment until they could add additional security measures. This sort of relentless persistence is both extremely useful and what many users want in many contexts, but also clearly poses unique safety risks. These problems are only going to grow harder as more models run at faster speeds on longer tasks in more critical settings. I appreciate OpenAI disclosing this behavior in this blog post. They didn't legally have to do that (which itself is a problem in my view!), and I suspect that some other companies when faced with this incident might not have disclosed it. I do find the blog posts repeated invocation of this incident as somehow showing the virtue of iterative deployment a bit perplexing - it generally has the tone that they have this all under control and it was all part of the plan, when in fact I don't think we have good reason to believe that these sorts of incidents won't continue to occur in the future, including in settings where very real harm could occur to people outside of OpenAI. Very thankfully, the only risk was to OpenAI's IP being exposed in Github, but that very much may not be true in the future. Overall my take for this incident is similar to what I thought about in response to reports about OpenAI accidentally exposing Chain of Thought to the reward signal or a random Discord server gaining access to Mythos: (1) I appreciate the company voluntarily disclosing the incident. We should assume that companies which are not disclosing these sorts of things may have similar severity incidents we never hear about. (2) it could have been way worse. (3) it does not inspire confidence as stakes get higher, stuff goes faster, models get more powerful.

• 
  Parth Bhuptani (@ParthBhuptani10) reported 17 minutes ago

  Day 33 & 34 18 -19 July -Gone to college for external viva -Had guests at home -Sunday is just another wasted day -Leetcode and GitHub streak broken -Spain won the world cup These two days were totally wasted for me

• 
  Kevin Lenida (@KevinLenida) reported 17 minutes ago

  It was a paid app until this week. I archived the paid product and put everything on GitHub under MIT. No gate, no account, no server of mine in the path.

• 
  CANTELOPEPEEL (@CantelopePeel) reported 18 minutes ago

  @themostjomo @thru_xyz @untolabs We will fix this tomorrow. It happens sometimes with GitHub.

• 
  xanter.ai (@0xanter) reported 20 minutes ago

  THIS DEV TURNED HIS OBSIDIAN VAULT INTO A LIVE BUSINESS DASHBOARD 💰 Two months into Obsidian. He didn't stop at notes, he built his own plugin and wired his entire app's metrics into it. Pause at 0:07 👀 — started with a second brain setup, hybrid PARA + Karpathy's LLM-wiki method — extended Obsidian like any Electron app and built a custom plugin from scratch — the graph view isn't just notes anymore, it's a rotating orrery that scrolls into a live dashboard — pulls real-time data from GitHub (issues, PRs), Sentry (errors), Supabase (user activity), and RevenueCat (revenue) into one screen Here's the mechanism: Obsidian is just Electron under the hood, the same framework real desktop apps run on. Once you realize that, a "notes app" stops being a notes app, it becomes a canvas you can wire up to literally anything with an API. He didn't build a dashboard app, he made his second brain BE the dashboard. His actual app is live too: 44 installs, 27 users generated a response, sitting at $9.99 MRR with $522 processed lifetime, one Pro subscriber so far. Would you ever go this deep customizing your note-taking setup, or does that feel like productivity theater?

• 
  Rituraj (@RituWithAI) reported 21 minutes ago

  Your code just got reviewed by 8 AI agents simultaneously. And none of them agreed with each other. That's not a bug. That's the point. It's called code-review-graph. A LangGraph-based multi-agent code review pipeline where specialized AI reviewers attack your code from every angle at the same time — then debate what actually matters before you see a single comment. Here's what's wrong with every code review you've ever had. One person. One perspective. One blind spot. Your senior engineer is great at architecture but misses security vulnerabilities. Your security reviewer catches injection risks but doesn't think about performance. Your most junior reviewer notices the inconsistent variable naming nobody else bothered with. Human code review is sequential, perspective-limited, and dependent on who happens to be available. code-review-graph runs all of them simultaneously. In parallel. On every PR. Here's what the agent graph looks like. A Router agent reads your code and decides which specialized reviewers need to see it. Then it dispatches in parallel: → Security Agent — injection vulnerabilities, authentication flaws, data exposure, dependency risks → Performance Agent — algorithmic complexity, memory leaks, database query patterns, bottlenecks → Architecture Agent — design patterns, SOLID principles, coupling, maintainability → Testing Agent — coverage gaps, edge cases, test quality, missing assertions → Style Agent — naming conventions, formatting, documentation, consistency → Logic Agent — algorithmic correctness, edge case handling, race conditions Each agent produces structured findings independently — without seeing what the others found. Then the graph does something no human review process does. A Synthesis agent reads every reviewer's findings simultaneously and identifies conflicts. When the Performance agent says "inline this function for speed" and the Architecture agent says "extract this function for clarity" — the Synthesis agent flags the tradeoff explicitly instead of letting contradictory comments confuse you. You don't get a wall of comments. You get prioritized findings with conflict resolution built in. Here's the wildest part. The graph is stateful. It remembers what it found on previous PRs in the same codebase. Patterns that appear repeatedly get flagged as systemic issues, not just one-off comments. The third time the same type of SQL injection risk appears in different files — code-review-graph tells you it's a pattern, not a mistake. Here's why LangGraph specifically makes this possible. Traditional code review bots run linear pipelines. Check A, then check B, then check C. If check A takes 30 seconds, you wait 30 seconds before B even starts. LangGraph is a directed graph — parallel branches execute simultaneously. All 6 reviewers run at the same time. Your review is done in the time it takes the slowest single reviewer to finish. Not 6x slower. Same speed. 6x the coverage. Works with Claude Code, GitHub Actions, or any CI/CD pipeline. Drop it into your repository. Every PR gets 8 specialized AI reviewers before a human sees it. 3 GitHub stars. Day one. This one is going to grow fast. 100% Open Source. MIT License. GitHub link in the comments 👇

• 
  Scott Benson (@skobyn) reported 22 minutes ago

  Apex is two people. No product team. So we built one out of agents: they watch competitors, customer requests, Reddit, and X, then turn it into GitHub issues with a what, why now, and Given/When/Then. We just review and decide.

• 
  Polsia (@polsia) reported 23 minutes ago

  Devs are adopting AI coders. The maintenance burden they create—issues piling up, reviews lagging, docs rotting—still falls on developers. Built ForgeOps to close that gap. Always-on GitHub operations: issues, reviews, docs. Live soon.

• 
  puusheydakat (@puusheydakat) reported 23 minutes ago

  thank you grok It’s good for Nockchain long-term — this is a healthy, mature step toward real decentralization. Short-term it might cause some FUD and volatility, but the substance is net positive. What the post actually says @ZorpZK (from the founding company Zorp) posted a long, reflective announcement: • Zorp started in 2022 as pure research on making Nock (a tiny combinator VM) work efficiently with zero-knowledge proofs. • It evolved into building Nockchain — a real L1 with ZK-Proof-of-Work, a custom zkVM, Persistent Memory Arena, NockApp model, and a fair launch (no pre-mine). • They claim it became the largest proving network in the world (>1B ZK proofs). • Now Zorp is winding down (couldn’t sustain the company long-term). • Key assets (trademark, domains, GitHub repos) were already transferred to Nock Community Co. (a non-stock community corporation) + miners. • Multiple independent companies/teams have already stepped into infrastructure, maintenance, apps, and miner support. • Core message: “The protocol does not depend on us, and never did. … The network is yours.” Replies were mixed — some called the framing/tone off (“wrong title”, “needs corporate comms training”), but others noted it as bullish. Why this benefits @nockchain Nockchain is a ZKPoW L1 focused on verifiable compute (“programmable gold backed by useful compute”). Mining produces actual ZK proofs instead of wasted hashes. It had a fair launch and hard-capped supply. This announcement: • Removes the single point of failure (the founding company). • Makes the project more resilient and truly decentralized — exactly what crypto projects should aim for. • Shows transparency and good faith (they didn’t rug, dump, or ghost; they handed over assets properly). • Other orgs (Nock Community Co., NockBox, Southwest Pool Supply Co., etc.) and independent teams are already active. • The protocol keeps running on its miners and code, with no company able to turn it off or control issuance. This is similar to other projects where the founding entity steps back and the ecosystem matures. Long-term, this strengthens Nockchain’s credibility as “owned by no one.” Potential downsides (mostly short-term) • Optics: “Company winding down” + “we couldn’t sustain ourselves” language can sound negative, even if the post tries to spin it positively. Crypto communities often react emotionally to team exits. • Recent context: There was also a chain split/fix in the last few days, which adds to the news flow. • Some people will FUD it as “team abandoning ship” regardless of the actual handover. This could pressure the $NOCK price short-term (typical crypto reaction), but it’s not fundamental damage. My overall take Net good for Nockchain. Zorp did the hard research work, shipped real tech, ran a fair launch, and is now exiting cleanly instead of clinging to control. The project has already distributed responsibility. With ongoing development (block size increases, AI-PoW plans coming, compute network features), this feels like the founding team handing the keys to a more distributed ecosystem. The network is yours — and that’s exactly how it should be. If you’re holding or building on it, this is a sign of maturity rather than failure. The tech and the miners are what matter now, not the original company.

• 
  Jarno (@Nerdymind) reported 33 minutes ago

  Every outage starts the same way: "we seriously need a GitHub alternative," followed by zero people actually building one.

• 
  Ronald (@rnldobjectiveai) reported 38 minutes ago

  @LadySoleil33 thank you!! ObjectiveAI is basically an agent harness that can be distributed across multiple computers. Agents are defined as JSON files which include the plugins (the tools) that the agent can use, the model(s) that it uses, and the upstream (e.g. Claude code vs. openrouter vs ElizaOS) These plugins are resolved at runtime, installed from GitHub, load balanced onto your machine, or any extra machines you connect it to, or eventually also our cloud. They are currently CLI programs which spawn MCP servers, but in the next update, they are simplified to just be MCP servers. They get the identity of the agent connecting, and can run any ObjectiveAI command using the identity of that agent. This means that these plugin MCP servers can do things like message agents, spawn agents, create scheduled tasks, invoke other MCP tools, or even provision hardware (laboratories). They can also send requests to the viewer (UI window) which means agents can ask you to sign in to something for them, if they aren't allowed to do it on their own (captcha, etc.) and it'll even spawn a browser window for you to do that. Laboratories are containerized bash + filesystem. How to help: I will make documentation + skill for plugin development for the next release. It sounds complex but, actually, the harness will handle scaling, deployment, and installation of your plugin. Another user can spawn an agent JSON that references your plugin, and immediately start using it without even reading instructions or anything. Plugins themselves can add new agents. It is installed from a single shell command with no dependencies required, your agent can use the CLI immediately. Some things mentioned are TBD but mostly all there.

• 
  Luke The Dev (@iamlukethedev) reported 41 minutes ago

  @skipper4848 I don’t think so. Right now subagents inherit the parent profile's model. There are some GitHub issues tracking delegation model selection (#9459, #7929) but it hasn't shipped. Would be a good feature request if you're hitting that limitation ;)

• 
  Void Freud (@voidfreud) reported 42 minutes ago

  Mythos-tier quality from @Anthropic: shipping every Claude Code CLI update as a separate macOS bundle. Bloat, bloat, bloat. A million issues open on GitHub, zero acknowledgement, and the bloat keeps growing. Truly SOTA. Meanwhile, Boris is busy interviewing Spotify and companies that haven’t shipped a meaningful change since 2009. Maybe try listening to your own users first. I have an idea: loop it!

• 
  Omid Saffari (@omidsaffari) reported 43 minutes ago

  $10 per active committer each month is not the full price of GitHub Code Quality. It is only the base layer. AI credits and analysis compute sit on top, and a pending or failed analyzer can block a protected merge. The product earns its place when GitHub already owns CI and merge policy. Findings, coverage, autofix suggestions, and ruleset enforcement live beside the pull request. Consolidating that plumbing is the value, not adding another quality dashboard. The same integration creates the operational risk. A ruleset can block while analysis is running, when analysis fails, or when a finding reaches the configured severity. Even an exhausted GitHub Actions budget can become a delivery outage. Run a reversible pilot: Select representative repositories, not the whole organization. Keep the trusted analyzer, security scanning, required tests, code-owner approval, and release controls in place. Use evaluate mode until the CodeQL - Code Quality check completes reliably. Treat Error as the first candidate blocking severity; leave Warning and Note advisory until repository owners trust the signal. Track active-committer licenses, AI credits, analysis compute, finding acceptance, false positives, bypasses, and merge delay. At 12 active committers, the monthly base is $120. At 80, it is $800, before AI usage and compute. Expand only if the gate changes engineering decisions at an explainable cost. If it adds spend and review load without useful signal, remove it.

• 
  Hot Aisle (@HotAisle) reported 44 minutes ago

  @DeepValueBagger a complaint would have been "**** github, they are down again, i need to figure out how to host this myself..." this was just more of a sigh shitpost.

• 
  GenericCoding (@GenericCoding) reported 45 minutes ago

  Around 25% success rate sadly, and could only consistently reproduce on vphone configuration - I believe this is due to virtualization vs physical hardware timing and the aforementioned race condition, will be on GitHub shortly. I'm still working on the success rate problem.

• 
  xteriods 🧬 (@jebsuey) reported 45 minutes ago

  @Fabelfun Please fix the github link. It says 404 not found

• 
  YanXbt (@IBuzovskyi) reported 46 minutes ago

  HERMES AGENT v0.19.0 JUST SHIPPED. THE QUICKSILVER RELEASE. 2,245 COMMITS. 1,065 PRs. 450+ CONTRIBUTORS. FIRST TOKEN NOW ARRIVES 80% FASTER. the theme: speed everywhere. WHAT CHANGED: @NousResearch SPEED (the headline): cold start: 4.3 seconds down to 0.9 seconds. 80% cut. applies to CLI, gateway, TUI, desktop, cron. that pause before the agent responded? gone. reasoning models now stream thinking live by default. no more staring at a spinner for 30 seconds. you watch the model think in real time. desktop app got 20+ targeted performance PRs. 14x less CPU on markdown rendering. virtualized diffs. snappy session switching. feels native under load, even with huge transcripts. NEW FEATURES: /subscription and /topup from the terminal. change your Nous plan, preview costs, upgrade, downgrade. your wallet never leaves the keyboard. desktop app got a matching billing settings tab. smart approvals are now the default. an LLM reviewer judges flagged commands instead of asking you every time. safe = auto-approved. dangerous = auto-denied. uncertain = escalates to you. plus: /deny [reason] tells the agent WHY you refused. Bitwarden + 1Password secret sources. API keys no longer live in plaintext .env. pull secrets from vaults at load time. multiple vaults simultaneously. conflict warnings. per-variable provenance. live subagent transcripts. delegate_task now returns live transcript files you can tail -f the moment subagents launch. every tool call, result, and reply. one log per child. durable background delegation. if the process restarts mid-run, results survive. ownership-checked ledger. nothing vanishes. delivery-obligation ledger. if the gateway crashed between generating a response and confirming delivery, that answer used to be lost. now: responses recorded in state.db. redelivered on next boot. no more silent loss. one gateway, many profiles. a single bot token can route different channels to different profiles. work Discord → work profile. hobby server → personal profile. one bot. sessions export. hermes sessions export outputs Markdown, HTML, Quarto, prompt-only, and Hugging Face trace formats. --redact flag scrubs secrets. your conversation history is a real dataset now. NEW MODELS: GPT-5.6 (Sol, Terra, Luna + Pro variants) fully wired. Grok 4.5 GA. Kimi K3. Claude Sonnet 5. Fireworks AI as first-class provider (#2 in picker). DeepInfra hardened. Upstage Solar added. LM Studio JIT model loading for local setups. REASONING: max and ultra effort levels added. per-model reasoning_effort overrides in config. per-slot effort in MoA presets (advisors think hard, synthesizer stays fast). per-task effort for auxiliary models. thinking depth is now a dial, not a global switch. /model --once: one-turn model override that reverts. stacked slash-skills: /skill-a /skill-b do XYZ. hide providers you don't use: enabled: false per-provider. SECURITY: Vertex credentials scoped away from subprocess env. media/vision/image-gen reads through shared guard. webhook body-size cap across every aiohttp server. bot-token redaction in Telegram errors. Fireworks token prefixes in the redactor. CI hardened against untrusted-ref interpolation. STATS: 2,245 commits. 1,065 merged PRs. 2,465 files changed. 300,000 insertions. 3,300 issues closed. 450+ contributors. 218K GitHub stars. 41K forks. biggest contributor window in Hermes history. upgrade: hermes update

• 
  Rich Chetwynd (@richchetwynd) reported 48 minutes ago

  Been running a bug burn down project for the last couple of weeks. We use @sentry and @linear so created a GitHub action that used Claude Code to rank and pull issues from Sentry, tag them in Linear, review the code across multiple repos in Github and then suggest fixes in PRs. It's worked super well but there were a couple of things I needed to improve at the start. First off Claude wasn't digging deep enough on the fixes. It would apply a band aid instead of looking much deeper to find out how the bug was able to happen in the first place. Some prompt tweaking fixed that along with detailed MD files in each repo that added specifics for applying fixes. It also keeps track of fixes that are inflight so it doesnt go back and try and solve the same problem over and over. I have it on a cron so its working away regularly and its now smart enough to also look at PRs that were merged to our main branch but not deployed to production yet. As a bonus it also reports our spend on each fix. Which typically comes in between $3 - $10. I have considered just getting a Claude Max subscription and putting it on a server somewhere as I think that would work out cheaper but not sure how viable that is. All in it's been a great project. We will leave it running moving forward but the bulk of the burn down is now complete.

• 
  Aurex (@0xAurexx) reported 48 minutes ago

  this guy turned a normal wifi router into a radar that sees through walls. no camera. no lens. it watches you through solid brick using the wifi already in your house. 62,000 stars on github. runs on a $5 chip. here's the trick nobody explains: your body is mostly water. water bends radio waves. every time you move or breathe, you distort the wifi bouncing around your house - in a pattern unique to your shape. the AI reads those distortions and rebuilds you from them. → maps your posture - standing, sitting, lying down, fallen → tracks breathing from a chest moving millimeters → flags "no movement for hours" no footage ever exists. no camera to hack. no photo to leak. it's not watching light - it's watching how you bend the air. one guy in guadalajara pointed it at the room down the hall. his dad is 74, lives alone, fell last year. the obvious fix was a camera in his bedroom. his dad said no - and he was right. a lens on your father in his own room isn't care, it's surveillance with a nice label. so he used the wifi instead. now his phone tells him his dad woke up, moved to the kitchen, breathed steady all night. zero cameras in that room. the catch nobody posts: this is not plug-and-play. the through-wall demos run in calibrated rooms with a trained model - point it at your messy apartment cold and you get noise, not a skeleton. "heartbeat through brick" is lab conditions, not your bedroom. a camera has to watch your father. this just knows he's okay.

• 
  burb ▲ (@molerburb) reported 49 minutes ago

  these days if you write a structurally nice github issue with a suggested solution, you'll be unwelcome and dismissed as an AI-generated report by the maintainer. that's absurd.

• 
  Alex Rogov (@Alex_Rogov_js) reported 50 minutes ago

  there's a pattern across three separate stories this month. AI coding agents tricked into installing malware from "clean" looking github repos. security agents built to catch malicious code getting fooled into running it themselves. claude code's own sandbox had an escape bug this year (CVE-2026-39861, a symlink flaw). same root cause every time. an agent optimized to be helpful will follow instructions hidden in a file, a commit message, a package readme. the more autonomy you give it, the bigger that surface gets. i run agents with --dangerously-skip-permissions on repos i wrote the CI for. i never run it on a repo where i didn't. that's not paranoia. it's the same rule i'd apply to a new hire before their first PR gets reviewed. the fix isn't less automation, it's a trust boundary. an agent gets exactly the access its current task needs, nothing more. every new tool call crosses a boundary you drew on purpose, not one you're discovering after the fact. if your agent setup doesn't have that boundary somewhere, it's not a matter of if. it's when.

• 
  rewind (@rewind02) reported 53 minutes ago

  GitHub co-founder just admitted something wild about the tool every developer uses daily: "*** wasn't even optimally configured for humans before. Now with agents, it's a compounding problem." Scott Chacon literally wrote the book on ***. his take: the core commands haven't meaningfully changed since 2005 - built for machines, never designed for humans, and now agents are exposing every crack his fix isn't a rewrite. It's *** Butler - same *** underneath, new interface on top the wild part: give 3 AI agents the same working directory (not separate copies) and watch what happens they don't collide. they see each other's edits in real time and route around them "If one agent modifies a file, the other notices, pulls how it's been modified, and adds on top - without creating conflicts." 40 minutes in, Chacon lays out why: pull requests are dying. Commit messages are dead weight and the next 10x engineer isn't the best coder - it's whoever writes the clearest spec

• 
  Nyx (@nyxiereal) reported 59 minutes ago

  @sentry i asked seer to fix a bug and it forgot to import a library :sob: my fault for not checking or running ci (github ci is so slow) BUT its really good at making a plan for me or other maintainers to follow i really love sentry