标签：#coding

Rust Ownership System Explained for JavaScript Developers Quick context (why you're writing this) I was trying to rewrite a small utility I’d written in JavaScript—a function that takes a string, splits it into words, and returns the longest one. In JS it’s trivial: you pass the string around, mutate arrays, and nothing blows up. When I attempted the same thing in Rust, the compiler kept yelling at me about “use of moved value” and “cannot borrow as mutable because it is also borrowed as immutable”. I spent a good chunk of an afternoon staring at those errors, thinking I’d missed some syntax detail, only to realize the real issue was a completely different way of thinking about data. If you’ve ever felt that Rust’s compiler is being overly pedantic, you’re not alone—but once you grasp what it’s protecting you from, the frustration turns into appreciation. The Insight Rust doesn’t treat variables like JavaScript’s loosely‑typed references. Instead, it enforces ownership at compile time. Three ideas tend to surprise developers coming from a garbage‑collected world: Move semantics – assigning a value to another variable moves it; the original is no longer usable unless you explicitly clone it. Borrowing rules – you can have either many immutable references or exactly one mutable reference to a piece of data, but never both at the same time. Lifetimes – the compiler tracks how long references are valid, preventing dangling pointers without a garbage collector. The first two are the ones that trip people up most often, and they directly address the class of bugs JavaScript developers know all too well: accidental shared‑state mutations and use‑after‑free‑like mistakes (though in JS they show up as weird undefined values rather than crashes). Let’s look at each with a concrete example, show the common mistake, and then see how to do it right. How (with code) Move semantics – the “you can’t use it after you give it away” surprise fn main () { let greeting = String :: from

Sliding Your Way Out of Panic: The Mental Trick That Speeds Up Coding Under Fire Quick context (why you're writing this) I still remember the sweat on my palms during a technical interview a couple of years back. The interviewer tossed out the classic “longest substring without repeating characters” problem, gave me five minutes, and watched me stare at the whiteboard like I’d never seen a string before. I started with a brute‑force double loop, felt the clock ticking, and ended up writing a mess that was O(n²) and full of off‑by‑one errors. I walked out feeling like I’d choked, even though I knew the solution deep down. Later, after I’d spent way too many hours replaying that moment in my head, I realized the problem wasn’t my knowledge—it was the way I was framing the question while under pressure. I’d been trying to solve the whole thing at once instead of focusing on the tiny piece that actually mattered. When I finally isolated that piece, the answer clicked in seconds. That’s the mental framework I now teach anyone who’s about to face a ticking clock: identify the invariant you must keep true, and let everything else revolve around it . The Insight When the pressure’s on, your brain wants to grab the biggest chunk it can see and start hacking. That’s a recipe for wasted time and bugs. Top coders do the opposite: they strip away everything that isn’t a constant rule the solution must obey, then build the smallest possible state machine that enforces that rule. For the substring problem the invariant is simple: the current window must contain only unique characters . If you can guarantee that, the answer is just the biggest size that window ever reaches. All the fiddly details—where to move the left pointer, how to know when a duplicate appears—fall out of tracking the last index you saw each character. So the mental steps are: State the invariant (what must always be true). Find the minimal data you need to enforce it (usually a map or a set). Update that data

Cursor's Developer Habits Report is one of the clearest signals yet that AI coding has crossed from individual productivity into software-delivery infrastructure. The headline numbers read as a story about speed: more code per week, larger PRs, deeper agent sessions, more changes committing without manual review. The deeper implication is governance -- whether teams can preserve architectural intent while generation, review, automation, and commit flows all accelerate at once. The velocity curve is now measured, not anecdotal. For two years the claim that AI coding is accelerating rested mostly on vibes and vendor decks. Cursor's data turns it into telemetry. And read as an operations document rather than a marketing one, that telemetry describes a structural shift: software delivery is getting harder to govern, not just faster to produce. This is not a critique of Cursor. The report is strong validation. Cursor proves the velocity curve with numbers most of the industry only gestured at. The point of this essay is what sits on the other side of that curve. What the Cursor Developer Habits Report Shows The inaugural Cursor Developer Habits Report (Spring 2026 edition), published by Cursor (Anysphere, Inc.), draws on Cursor usage data rather than survey responses. It captures the transformation across five themes -- developer acceleration, the economics of intelligence, the power user gap, the rise of context, and the shift to automation. The headline figures: 3.6K -> 8.6K lines added per developer per week -- the per-developer code volume rose from 3.6K (Jan 2025) to 8.6K (May 2026), with growth accelerating since the start of 2026. 125.86 -> 345.02 lines per PR at p75 -- lines added per pull request at the 75th percentile rose roughly 2.5x year over year (Jan 2025 to May 2026). Developers are taking on larger units of work in a single PR. 8% -> 13.8% mega PRs -- the share of PRs with at least 1,000 changed lines grew from 8% (Jan 2025) to 13.8% (May 2026). ~30% mor

AI Coding Agents in 2026: From Pair Programming to Autonomous Teams Slug: ai-coding-agents-2026-stack-comparison 1. The Three Categories That Actually Matter The 2024‑2025 hype cycle treated every AI coding tool as a single‑dimensional “best‑of‑list.” 2026 data shows that professional developers now average 2.4 tools per workflow (Stack Overflow Survey 2025). The real decision is architectural: Layer Goal Typical Agent Type Line‑level editing Speed, low latency Editor assistants Repo‑level planning Context depth, multi‑file changes Autonomous agents Enterprise governance Isolation, audit, CI/CD integration Platform agents Choosing a “one best tool” ignores the trade‑off between context window size (how many tokens the model can see) and execution speed (how fast the tool returns a suggestion). A narrow‑window editor assistant excels at instant autocomplete, while a wide‑window autonomous agent can rewrite an entire microservice in a single run. The three‑tier framework aligns the tool’s strengths with the architectural layer where they matter most. 2. Tier 1: Editor Assistants — Speed at the Line Level Tool Market Position Key Feature (2026) Pricing (per developer) Cursor $500 M+ ARR, fastest growth in Q1 2026 Parallel agents update git worktrees; 2‑second latency on 8‑core laptops $15 /mo (individual) – $120 /mo (team) GitHub Copilot 4.7 M paid subscriptions, 75 % YoY growth Agent Mode with multi‑agent workflows; deep VS Code integration $10 /mo (individual) – $100 /mo (enterprise) Windsurf 1.2 M active users, strong UI polish Real‑time code‑style enforcement; limited to 4‑file context Free tier up to 5 k lines, $30 /mo premium Tabnine Enterprise‑only after 2026 pivot Air‑gapped deployment; NVIDIA Nemotron 4‑bit models for on‑prem inference $200 /mo per seat (minimum 10 seats) When to choose each Cursor – prioritize raw typing speed and git‑aware suggestions. Ideal for startups that need rapid iteration without heavy IDE lock‑in. Copilot – best for teams already on

Qwen3.7-Plus has appeared on Qwen's official research release page, with a release date of June 1, 2026. Chinese media covered the launch on June 2. The important part is not that Qwen 3.7 Plus can understand images. The bigger signal is that Qwen is pushing it as a multimodal agent model: vision, language, coding, tool use, and productivity workflows inside one task loop. For developers, the real question is simple: can it keep the same goal across software screens, web pages, screenshots, code, terminal output, and tool calls long enough to finish useful work? If your team is evaluating new agent models, keep the model shortlist in one place and compare quality, latency, cost, and failure modes by task: Compare AI models on WisGate . What Is Qwen3.7-Plus? Qwen3.7-Plus is a multimodal agent model from Qwen. Qwen describes it as an agent foundation that unifies vision and language. It builds on the Qwen3.7 text backbone, adds stronger vision-language capabilities, and keeps the agent-oriented strengths developers care about: coding, tool use, and productivity workflows. That makes it different from a basic image-question-answering model. The more useful use cases look like this: Read a UI screenshot and decide the next action. Combine web pages, docs, charts, screenshots, and text context. Turn a design or product screen into maintainable code. Use tools to verify results instead of only returning static answers. Move between GUI, CLI, browser, and code environments during one task. That is why Qwen3.7-Plus should be evaluated as an agent model first, not just as another chat model with vision support. Why This Release Matters More teams are moving models into longer workflows: read the request, inspect the code, run tests, check logs, fix the issue, verify again, and write the summary. The hard part is that real work is rarely text-only. Frontend bugs come with screenshots. Dashboards come with tables and charts. Debugging comes with terminal output, browser state,

Over the past few months, I’ve increasingly noticed something through my network: more people from non-technical backgrounds are building software as AI tooling improves. Designers are prototyping product ideas. Product managers are testing workflows. Founders are building MVPs. Operators are creating internal tools. People who would not have called themselves “technical” a year ago are now using AI to make ideas tangible. I think this is genuinely exciting. It has never been easier to create. I even attended a hackathon where participants only had 20 minutes to build a demoable product! This raises the question: When AI makes building easier, how do we make sure understanding does not disappear? I recently published Thinking in the Age of AI , a guide for software engineers (you can check out my previous post here ). That guide focused on individual reflection for engineers: how to keep developing technical intuition, reasoning, and judgment while using AI tools. But the landscape has changed quickly. AI-assisted building is no longer only an engineering workflow. It is becoming a builder workflow accessible to all. And by builders, I mean anyone using AI to turn ideas into software-like artifacts: vibe coders designers product managers founders operators marketers students non-engineering team members So I wanted to create a new version of the system for this wider builder audience. Thinking in the Age of AI: Builder Edition The opportunity is real I do not think we should dismiss this shift. I have spoken with people from all kinds of backgrounds who are actively building now. People who previously had to wait for engineering time can now create something concrete. That changes the conversation. Instead of describing an abstract idea, you can show a flow. Instead of writing a long product spec, you can prototype the interaction. Instead of asking “would this work?”, you can test a rough version. That is powerful. But there is a trap. A prototype can look much mor

This article was originally published on aicoderscope.com In early 2023, Andrej Karpathy coined the term "vibe coding" to describe a new mode of software development: you describe what you want, the AI writes the code, and you ship without reading every line. He meant it as a genuine observation about where the craft was headed. By 2026, vibe coding is the default mode for most solo developers, with AI tools handling roughly 70% of keystroke work on a typical feature. The other 30%—direction, review, judgment—still belongs to the human. The pitch is real. Solo developers can now build features that would have taken a week in a day. The bottleneck isn't code volume anymore; it's knowing what to build. That's a genuine productivity unlock. The problem is also real. Codebases vibe-coded without guardrails develop a specific pathology: inconsistent patterns across files (because each AI session starts with no memory of the last), logic errors masked by plausible-looking code, and no rollback culture because no one committed before letting the AI loose. The developer who vibed their way through six weeks of feature work often can't explain what the codebase does anymore, because they never had to think through it. This guide is not about slowing down. It's about the ten rules that let you keep the speed without the debt. The Promise vs. the Reality What vibe coding looks like in 2026: you open Cursor, describe the feature in natural language, and Agent mode writes the file. You review the diff, accept what looks right, reject what looks wrong, and move on. For standard CRUD features, state management, boilerplate API clients, and UI components, this works well. The AI has seen enough patterns that its output is often correct on the first try. Why it works especially well for solo devs: there's no code review bottleneck. A team has to slow down to onboard the AI's changes into shared mental models. A solo developer owns the whole context and can iterate without waiting fo

This article was originally published on aicoderscope.com On April 28, 2026, Warp open-sourced its terminal client under AGPL-3.0, picked up 60,000 GitHub stars, and declared itself an "agentic development environment." OpenAI signed on as founding sponsor. The announcement looked like a triumph of developer-first idealism. Read the fine print and a different picture emerges: the terminal is free; the product that matters — Oz, Warp's cloud agent orchestration platform — remains fully proprietary. Warp is not becoming an open-source project. It is becoming an enterprise SaaS company with an open-source frontend. None of that is inherently bad. But it is what this review is actually about: does the $20/month Build plan deliver enough AI value to justify adding Warp to a stack that probably already includes Cursor or Claude Code? What Warp is in May 2026 Warp's product now has three layers: Warp Terminal — the terminal client, open-source AGPL-3.0. Rust-based, GPU-accelerated, available on Mac, Linux, and Windows. The core terminal features (blocks, Warp Drive, session sharing, settings file) are free and remain free. Warp Agent — an AI coding agent embedded in the terminal. Runs locally for interactive work. Handles natural language command generation, code review, debugging assistance, codebase Q&A, and voice input. Consumes credits from your plan. Oz — Warp's proprietary cloud orchestration platform. Runs agents in the background, coordinates multi-agent workflows, triggers on events from Slack, Linear, or GitHub Actions, and orchestrates third-party CLI agents including Claude Code and Codex. Oz is where the enterprise pitch lives. Around 1 million developers use Warp as their primary terminal. The pivot to agentic tooling is a bet that those developers will pay to automate their workflows beyond what a local agent session can handle. Pricing breakdown Warp simplified its pricing in December 2025, replacing the old Pro/Turbo/Lightspeed tiers with two paid plans. P

Inspired by a similar project called GenosDB and Cloudflare’s initiative to rebuild Next.js, I decided to rebuild GunDB with a modern coding style, incorporating improvements and addressing shortcomings in the original technology. I used the OpenCode tool with the Big Pickle model to rewrite the project in a new graph database called Garfo (the Portuguese word for “fork”), and I was impressed with the results and its practical applications. In this article, I’ll explain the technology and its improvements over GunDB. Introduction Garfo is a modern, browser-first fork of GUN.js — the decentralized, offline-first graph database. A fork of the original project that keeps the familiar GUN graph API while bringing meaningful improvements to the modern JavaScript ecosystem. Why a Fork? GUN.js is a revolutionary technology — a graph database that syncs in real time, works peer-to-peer, resolves conflicts automatically, and runs in the browser. However, the JavaScript ecosystem has evolved. TypeScript has become the standard, ES modules are the norm, and new transport layers like Nostr have emerged as promising decentralized protocols. Garfo was born to fill these gaps: a GUN rewritten with modern typing, designed with the browser as a first-class citizen, and with native support for the Nostr protocol. Key Features Familiar Graph API If you've used GUN before, you'll feel right at home. Garfo exposes the same chainable API: import Garfo from ' garfo ' ; const db = new Garfo ({ localStorage : true }); db . get ( ' users ' ). get ( ' alice ' ). put ({ name : ' Alice ' , status : ' online ' }); db . get ( ' users ' ). get ( ' alice ' ). on ( profile => { console . log ( ' Update: ' , profile ); }); All the classic methods are there: get() , put() , set() , on() , once() , map() . Optional Nostr Transport This is one of the most exciting additions. Garfo can use Nostr relays as a transport layer, allowing peers to exchange graph messages through public or private relays: const

In this post i'm gone explain liked list an famous leetcode problem that is " Remove Nodes from linked list ". Problem Statement: You are given the head of a linked list. Remove every node which has a node with a greater value anywhere to the right side of it. Return the head of the modified linked list. Example 1: Input: head = [5,2,13,3,8] Output: [13,8] Explanation: The nodes that should be removed are 5, 2 and 3. Node 13 is to the right of node 5. Node 13 is to the right of node 2. Node 8 is to the right of node 3. Explanation: In this problem statement state that remove the nodes which have the right side (any place) element greater than. let's understand with given example. Node 13 is the right side of the 5,2 nodes thats why 2,5 should be remove. Node 8 is the right side of 3 node thats why 3 should be remove. final result would be [13,8] Solution of the problem: `/** * Definition for singly-linked list. * function ListNode(val, next) { * this.val = (val===undefined ? 0 : val) * this.next = (next===undefined ? null : next) * } */ /** * @param {ListNode} head * @return {ListNode} */ const reverList = function(head){ let prev = null; let curr = head; let next = null; while(curr!=null){ next = curr.next; curr.next = prev; prev = curr; curr = next; } return prev; } var removeNodes = function(head) { // reverse list let reversList = reverList(head); let maxNode = reversList; let prevNode = reversList; let currNode = reversList.next; // removed list while(currNode != null){ if(maxNode.val > currNode.val){ currNode = currNode.next; }else{ maxNode = currNode; prevNode.next = currNode; prevNode = prevNode.next; currNode = currNode.next; } } prevNode.next = null; // reverse list return reverList(reversList); };` If you have any query or suggestions leave your expression👨🏿‍💻🙌.

I have been a Python developer for two years. I know Flask, basic machine learning, and I have built a few automation scripts. But when a friend asked me to build him a simple mobile app — something clean, with a login screen and a dashboard — I froze. Mobile development felt like an entirely different world. That experience pushed me to explore something I had been ignoring: AI-powered no-code app builders . What I found completely changed how I think about building software. The Problem With Traditional App Development Most developers think in terms of languages and frameworks. Want an Android app? Learn Kotlin. Want iOS? Learn Swift. Want both? Learn Flutter or React Native. The learning curve is real and the time investment is massive — especially for solo developers or small teams trying to ship fast. But here is the thing nobody tells you early enough: the tool is not the product. The problem you solve is the product. AI tools in 2026 have made it possible to separate these two things. You focus on the problem. The AI handles the implementation. What I Actually Used After researching for about a week, I landed on a combination that worked surprisingly well for my use case. FlutterFlow handled the UI. It is a visual builder that outputs real Flutter code — not some locked-in proprietary format. I dragged and dropped my screens, used the built-in AI generation feature to scaffold entire pages from text prompts, and connected everything to Firebase in about four clicks. ChatGPT filled the gaps. Whenever I hit something FlutterFlow could not handle visually, I described what I needed in plain English and got working Dart code back within seconds. No Stack Overflow rabbit holes. No three-hour debugging sessions. Firebase was the backend. Authentication, real-time database, push notifications — all free at my scale, all connected without touching a server. The result? A working Android app in three days. Not a prototype. A real, testable app that I deployed to Googl

Cognition makes Devin, the first and arguably most successful AI coding agent. But famed coder Wu says it isn't designed to supplant human programmers.

How vibecoding is destroying the open source that feeds it March 3, 2026 The snake eating its own tail A year ago, vibecoding was a curiosity. Today, it’s an industry. Millions of developers — or rather prompters — generate entire applications by describing what they want to an LLM. In minutes, an API, a frontend, a deployment. Magical. But behind this magic lies a dirty secret that nobody wants to face: every line of code generated by these AIs was trained on millions of open source projects — projects that are now dying. Vibecoding would be nothing without open source. And it’s killing it. What exactly is vibecoding? For those who spent 2025 in a cave: vibecoding is the practice of creating software in natural language, relying on generative AI models (Claude, GPT-5, Gemini, and the dozens of specialized models that have emerged since). You describe a vibe , an intention, and the AI produces the code. No debugging. No reading documentation. No Stack Overflow. And above all — here’s the crux — no contributing back . The implicit pact of open source is broken The open source ecosystem has always rested on a tacit social contract: I publish my code for free. In return, others use it, find bugs, suggest improvements, contribute. The project lives because a community keeps it alive. This contract had already been severely tested by large corporations that consume open source without contributing proportionally. But at least the developers who used these libraries understood them. They opened issues. They forked. They sent pull requests. They wrote blog posts that spread the word about the project. Vibecoding has blown up this cycle. The vibecoder doesn’t know which library they’re using. They don’t know, and they don’t care. They asked “build me a payment API with webhook handling,” and the AI chose this or that dependency for them. They will never read that project’s README. They will never open an issue. They won’t even know that project exists . The chilling numbers

One poisoned extension, one package install, one CI workflow. Any of them can now be the first domino. That is the uncomfortable lesson from the latest Shai-Hulud activity and GitHub’s recently confirmed internal-repository breach. The scary part is not only the number of affected packages, tokens, or repositories. Counts move fast. The scarier part is where the attacker code ran: inside the trusted developer and CI path. The modern supply chain is not just “the dependencies we ship to production.” It is your IDE, your package manager, your GitHub Actions runner, your cache keys, your OIDC flow, your local gh auth, your AI coding tool config, and the cloud account that quietly pays the bill when something goes sideways. What happened, briefly CISA described the original Shai-Hulud wave as a self-replicating npm worm that compromised more than 500 packages and targeted GitHub personal access tokens plus AWS, GCP, and Azure keys. GitHub later said it removed 500+ compromised packages and began pushing npm toward shorter-lived credentials, 2FA enforcement, and trusted publishing. The later waves got more CI-aware. Instead of only stealing npm tokens from maintainers, they looked for credentials inside build environments, abused publishing workflows, and used the build system itself as distribution. Microsoft’s May 2026 reporting on the @antv ecosystem described a “Mini Shai-Hulud” style campaign that targeted GitHub Actions environments and stole GitHub, AWS, Vault, npm, Kubernetes, and 1Password secrets. Microsoft said GitHub removed 640 malicious packages and invalidated 61,274 npm granular access tokens with write permissions and 2FA bypass. Then GitHub confirmed an incident involving a compromised employee device and a poisoned third-party VS Code extension. GitHub said the attacker’s claim of roughly 3,800 internal repositories was “directionally consistent” with its investigation, while also saying its current assessment was exfiltration of GitHub-internal reposi

As Cognition reaches $492 million in annualized revenue run rate, it more than doubled its valuation in eight months, it says.

Pullfrog is an open-source AI-powered GitHub bot by Colin McDonnell, designed for automation in GitHub Actions. It supports a model-agnostic approach, allowing integration with various LLM providers. Key features include orchestration for pull request reviews, issue triage, and CI remediation, all managed within GitHub's environment. The tool operates with a bring-your-own-key model for access. By Daniel Curtis

Last year, I met a young translator reinventing herself. She studied Translation for five years at a...

We are committed to empowering every developer by building an open, secure, and AI-powered platform that defines the future of software development. The post GitHub recognized as a Leader in the Gartner® Magic Quadrant™ for Enterprise AI Coding Agents for the third year in a row appeared first on The GitHub Blog .