I wanted AI code review I could actually own. Not access through a subscription or a black-box service with its own limits. The deployment, credentials, providers, and usage under my control. I kept hitting usage limits mid-week during deep building sessions. The models were capable. The workflow was useful. But access still depended on somebody else's weekly allowance, and centralized platforms can change whenever the company behind them decides to. Pricing, quotas, models, plan boundaries. A workflow that fits this month may sit behind another subscription next month. I could not find a reliable open-source option that gave me the ownership model I wanted. So I built one. That became Codra : A self-hosted AI review engine built around bring-your-own models, your own data boundary, and no Codra-imposed usage ceiling. What Codra Is Codra is an open-source, self-hosted AI code review engine for GitHub pull requests. It listens to pull request events, reviews changed files, posts inline findings, and provides a dashboard for jobs, repositories, model routing, history, usage, and failures. It runs on Cloudflare Workers and uses: Cloudflare Queues for review jobs PostgreSQL through Hyperdrive for storage KV for sessions and cache A React dashboard for operations The GitHub App, model credentials, database, and review history are yours. Provider keys are encrypted with AES-GCM using your deployment secret. Bring Your Own Model, Bring Your Own Limits Changing providers does not require replacing your review history, configuration, or workflow. You configure the provider and model. Supported: OpenAI-compatible APIs OpenRouter Anthropic Google / Gemini Cloudflare Workers AI Why Self-Hosted Matters Here A large frontend repo and a tiny backend repo should not need the same review strategy. Each repository gets its own review settings. You tune triggers, skip generated files, ignore drafts, use mention-triggered reviews, configure labels, set file limits, and define custom ru

One of the most confusing errors you can face while deploying a Node.js or Docker-based application is: fatal: Need to specify how to reconcile divergent branches At first glance, it looks like a Git bug. In reality, it is Git doing exactly what it should do, protecting you from overwriting history. In this article, I’ll break down a real production incident where a deployment failed due to divergent Git branches, how we diagnosed it, and the correct DevOps fix. The Problem A simple deployment script was running: git pull docker compose down --remove-orphans docker compose up --build -d But it failed with: fatal: Need to specify how to reconcile divergent branches This stopped deployment completely. What Git Was Telling Us To understand the issue, we ran: git rev-list --left-right --count HEAD...origin/main Output: 1 16 This means: 1 commit exists locally on the server 16 commits exist on GitHub So the branches had diverged. Why This Happens (Important) This usually happens when: Someone runs git commit directly on a server A previous deployment used git pull with merge commits History between local and remote is no longer linear Git refuses to guess whether you want to: Merge Rebase Or reject changes So it throws an error. Deep Diagnosis We inspected the commits: git log --oneline origin/main..HEAD Result: 6d9046b Merge pull request #222 Then: git log --oneline HEAD..origin/main Showed multiple new GitHub PR merges. Conclusion: The server was behind GitHub The “local commit” was already part of repo history No real production changes existed on server The Real Fix (Production Safe) For deployment servers, you should NEVER rely on git pull . Instead, use a deterministic reset: git fetch origin git reset --hard origin/main Then redeploy: docker compose down --remove-orphans docker compose up --build -d Why This Works This approach ensures: Server always matches GitHub exactly No merge conflicts in production No accidental local commits survive Fully reproducible depl

Superhuman, which also has an AI detection tool as part of Grammarly, has snapped up GPTZero.

If you've ever wanted your AI coding agent to do more than just write code — to actually plan , validate , and cost-estimate real cloud infrastructure — the new Terraform Ops Kit for Docker Sandbox (sbx) is here to make that happen. This community-contributed kit, submitted to the docker/sbx-kits-contrib repository, brings a production-ready Infrastructure-as-Code (IaC) toolkit straight into the sandbox environment where agents like Claude, Gemini, GitHub Copilot, and Shell already run. What Is a Sandbox Kit? Docker Sandbox ( sbx ) is a runtime environment where AI agents operate. Kits are modular add-ons that extend the capabilities of those agents — think of them as pre-configured toolboxes that get installed automatically when a sandbox is created. The Terraform Ops Kit is a mixin kit , meaning it can be layered on top of any existing agent setup without replacing or conflicting with other kits. What's Inside the Kit? When the Terraform Ops Kit is activated, six tools are pre-installed and ready to use inside the sandbox: Tool Purpose Terraform Core IaC engine — plan, apply, and destroy infrastructure Terragrunt Terraform wrapper for DRY configurations and multi-account workflows tflint Linter for catching Terraform misconfigurations before they're applied Checkov Static analysis security scanner for IaC files Infracost Cost estimation — know the price tag before you deploy AWS CLI Interact with AWS services directly from the sandbox Together, these tools enable AI agents to autonomously carry out the full infrastructure development lifecycle: write Terraform code, lint it, scan it for security issues, estimate its cost, and plan the deployment — all without leaving the sandbox. Why This Matters Infrastructure work has traditionally required a human-in-the-loop at every step. You'd write the config, then manually run terraform plan , then check the security scan, then get a cost estimate — context switching across multiple tools. With the Terraform Ops Kit, an AI

Live autonomous AI DJ that digs, mixes & explains 24/7 Discussion | Link

Hi there, im currently coding a datapack for minecraft, combining BlazeandCave's Advancements pack with my own datapack for a series I want to start, but I cant figure out how to code what I want exactly, since it seems like it never works. If anyone knows how to help me, heres what I was thinking of coding: Information: BlazeandCave's Advancements is a pack that adds more advancements to the game. I want every advancement to expand a starting border of 16 blocks every time by: Task: 1 Goal: 2 Challenge: 5 Super challenge: 20 I also don't want it so that if I get an achievement, my friends cant expand the border with that achievement no more. I also want to add a daily challenge of obtaining certain items, and gives me 3 lucky blocks on completion, but Im working on that later, rn im just stuck on the Achievement part. Im currently using https://code.visualstudio.com/ for all my coding. Help is appreciated My code: -datapack --data ---border\function ----check_adv.mcfunction: execute as u/a store result score u/s adv_now run scoreboard players get u/s bac_statistics execute as u/a if score u/s adv_now > u/s adv_old run worldborder add 1 execute as u/a if score u/s adv_now > u/s adv_old run scoreboard players operation u/s adv_old = u/s adv_now ----load.mcfunction: scoreboard objectives add adv_now dummy scoreboard objectives add adv_old dummy worldborder set 16 worldborder center 0 0 ----reward.mcfunction: scoreboard players add #adv adv_count 1 ----tick.mcfunction: function border:check_adv ---minecraft\tags\functions: ----load.json: {"values":["border:load"]} ----tick.json: {"values":["border:tick"]} --pack.mcmeta: { "pack": { "pack_format": 18, "description": "Border SMP datapack" } } -BlazeandCave's Advancements pack 1.20.2.zip submitted by /u/Initial-Honey-9865 [link] [留言]

submitted by /u/caspervonb [link] [留言]

AI can generate a test script before you finish your coffee. That sounds like the hard part of test automation has finally been solved. In practice, most teams were never blocked by the first script. They were blocked by everything that came after it: maintenance, flaky runs, slow feedback, weak adoption, unclear ownership, browser differences, and the uncomfortable question of whether the suite is saving more time than it consumes. That is the theme I keep coming back to when I look at test automation in 2026. Creating tests is getting easier. Building a testing system that people trust is still difficult. Here is a practical map of the problems teams are dealing with now, along with deeper guides for each one. Start with the outcome, not the framework A surprising number of automation projects begin with a tool debate. Should we use Selenium? Playwright? Cypress? A no-code platform? An AI agent? Those questions matter, but they come too early. Before choosing a framework, it helps to agree on what test automation actually is , what risks you are trying to reduce, and which feedback needs to arrive faster. For a team starting from scratch, the most useful approach is usually smaller than expected. Pick a business-critical flow, automate it, run it consistently, and learn from the maintenance burden before expanding. This guide to getting started with automated testing explains that process without pretending every manual test should immediately become code. It is also important to distinguish individual checks from genuine end-to-end testing . A test that confirms a button is visible can be useful, but it does not tell you whether a customer can sign up, receive an email, complete a payment, and see the correct result in another system. Teams naturally ask for the fastest way to automate tests . The honest answer is that speed is not just the time needed to create version one. The fastest approach over six months is the one your team can understand, run, repair, an

Everything is expensive. Treat yourself to one of these WIRED-tested and -approved Prime Day picks under $30.

Almost everything that makes the modern world hum, from the phone in your pocket to the sensor on a factory floor, traces back to a single quiet afternoon in a nearly empty laboratory in Dallas. In the summer of 1958, a newly hired engineer named Jack Kilby built the first working integrated circuit at Texas Instruments. It was a crude little thing, a sliver of germanium with a few components and some fine gold wires, but it carried an idea that would reshape electronics: that an entire circuit could be made from one piece of semiconductor material. Every microcontroller and connected device we build today is a descendant of that prototype. The engineer who was left behind Kilby had only just joined Texas Instruments and had not yet earned any vacation time. So when the company shut down for its traditional summer break in July 1958 and most of his colleagues left, he found himself nearly alone in the lab with time to think. The problem on his mind was one the whole industry called the "tyranny of numbers." Circuits were getting more capable, which meant more transistors, resistors, and capacitors, each one a separate part that had to be wired together by hand. Every added component meant more connections, more soldering, and more chances for something to fail. The complexity was becoming a wall. Kilby's insight was disarmingly simple. If resistors and capacitors could be made from the same semiconductor material as transistors, then every part of a circuit could be fabricated together in a single block. No separate components, no forest of hand-soldered wires. He sketched the idea, and when his managers returned he had something to show them. September 12, 1958 On September 12, 1958, Kilby demonstrated his prototype to Texas Instruments executives. The device was a phase-shift oscillator built on a bar of germanium, with its elements connected by delicate gold "flying wires." He connected it to an oscilloscope, flipped the switch, and a steady sine wave rolled acro

The Quest Begins (The "Why") Honestly, I still remember the first time I stared at the Daily Temperatures problem on LeetCode and felt like I was trying to crack a vault with a toothpick. The brute‑force solution — two nested loops, checking every future day for a warmer temperature — was simple to write, but it timed out on the larger test cases. I spent an hour tweaking loops, adding early breaks, and even trying to memoize results, only to watch the same red “Time Limit Exceeded” banner flash again. I was frustrated, but more than that, I was curious. Why did this problem feel so repetitive ? Every element seemed to be asking the same question: “What’s the next greater value to my right?” If I could answer that for each index in a single pass, the whole thing would collapse into O(n). That’s when I remembered a weird little data structure I’d seen in a textbook — the monotonic stack — and realized it might be the magic wand I needed. The Revelation (The Insight) Here’s the thing: a monotonic stack isn’t just a stack with a funny name; it’s a way to capture relationships between elements without ever looking backward more than once . Imagine you’re walking through a line of people sorted by height, and you want to know, for each person, who is the first taller person standing ahead of them. If you keep a stack of people whose heights are strictly decreasing as you move from left to right, then whenever you see a new person taller than the one on top of the stack, you’ve just found the answer for that stacked person: the current person is their “next greater.” You pop them off, record the distance, and keep going. Because each index is pushed once and popped at most once , the total work is linear. The same idea works for “next smaller,” “previous greater,” or any problem where you need the nearest element that satisfies a monotonic condition. The stack does the heavy lifting of remembering candidates that could still be relevant, discarding the ones that are alrea

I got a take-home assignment last year from a company I was genuinely excited about. "Should take about four hours," the recruiter said. Build an ingestion pipeline, model the data, write tests, document your design decisions, and prepare a 15-minute presentation walkthrough for the panel. Four hours. I laughed, closed my laptop, and started on it the next morning like it was a sprint. Sixteen hours later I had something I was proud of. Clean pipeline, solid tests, real documentation. I submitted it on a Sunday night. Monday I got a form rejection. No notes. No feedback. Not even which stage I failed. Just "we've decided to move forward with other candidates" and a link to their Glassdoor page. That was the moment I stopped pretending take-homes are assessments. They're consulting gigs. Unpaid ones. The Scope Creep Nobody Talks About Five years ago, a data engineering take-home was a focused exercise. Model this dataset into a star schema. Write a few SQL transforms. Maybe a short README. Two to four hours, tops. Bounded, reasonable, and actually useful for evaluating how someone thinks about data. That version is dead. Today, 68% of companies use take-home tests, up 12% year over year. And the scope has quietly ballooned into something unrecognizable. Full pipeline implementations. Test suites with coverage thresholds. Documentation that reads like a design doc. A presentation follow-up where you defend your architecture to a panel. We're talking 10 to 20 hours of work, routinely, for a role you haven't been offered. Industry best practice caps take-homes at 90 minutes of expected effort. The reality? Candidates consistently take 2x longer than company estimates to reach submission quality. That "four-hour" assignment is an eight-hour assignment. That "weekend project" is a week of evenings. And 25% of companies are still handing these out like they're reasonable asks. Here's the part that makes my eye twitch: 71% of engineering leaders openly say take-homes no lon

APIs para agentes autónomos: lo que Prowl muestra (y no muestra) El snapshot actual de Prowl lista cinco APIs con score n/a. Eso ya es una señal: ninguna de estas herramientas tiene aún suficiente adopción o señales de ranking. Pero no por eso son irrelevantes. Al contrario, agrupan un patrón común: todas están diseñadas para que un agente de IA opere sin intervención humana directa. Los items y su función Apumail — casilla de correo nativa para agentes. Ofrece una API en texto plano, con negociación de contenido: text/plain para agentes, HTML para humanos. Útil para workflows donde el agente necesita recibir confirmaciones, códigos o enlaces verificables. RogerThat — capa de coordinación entre agentes. Mensajería en tiempo real pensada para que agentes autónomos se comuniquen entre sí. No es un chat humano, es infraestructura de sistema distribuido. DOBI — agente autónomo enfocado en DePIN y activos del mundo real. Ejecuta acciones on-chain dirigidas por un agente de IA. Combina blockchain con decisión autónoma. CIDIF — plataforma para gestionar solicitudes de fondos de I+D. Automatiza el proceso burocrático. No es un agente puro, pero su API podría integrarse con un agente que busque oportunidades de funding. Orquesta — orquestación de pipelines multi-paso para agentes. Permite componer, ejecutar y monitorizar workflows complejos. Es el eslabón que une agentes individuales en procesos coordinados. Patrón detectable Cuatro de cinco herramientas están directamente orientadas a agentes autónomos. La quinta (CIDIF) es una plataforma funcional que puede ser consumida por un agente. Esto indica una dirección clara en el ecosistema: la IA no solo habla con humanos, ahora necesita canales propios, comunicación entre sí, y capacidad de actuar sobre sistemas reales (blockchain, email, workflows). Señales no obvias Score n/a en todas : ninguna ha acumulado suficiente tráfico o votos para generar un score. Esto sugiere que el mercado de APIs para agentes está en etapa tempran