标签：#coding

I’ve used quite a few AI design tools, but I was always thinking about what might happen when I stop...

Last summer I built an AI chatbot almost entirely in Claude Code. It worked. I never pushed it to GitHub. I felt that putting my name on a public repo felt like making a claim I couldn't back up. There is a particular kind of quiet that follows building something you don't feel entitled to. No matter how rewarding the project feels, somewhere behind your ribs a voice says: you didn't actually do that. If you've felt it, you already know the argument I'm about to make against. The stigma, stated fairly The criticism deserves better than a strawman, so here it is at full strength. Skill comes from struggle. When you sit with a bug for three hours, you're not just fixing the bug - you're building a mental index of how this kind of thing breaks. The frustration is the encoding mechanism. Hand the struggle to a model and you get the fix without the index. Do that a thousand times and you've shipped a thousand features while learning almost nothing, and you won't find out until the day the model is wrong and you have no idea it's wrong. There's a second, harsher version: that AI-dependent developers are pricing themselves as engineers while functioning as typists, and the industry hasn't caught up yet. I think both of these are pointing at something real. I just think they've misidentified the cause. The real failure mode Here's the honest part, and I want to say it before the defense, because a defense that skips it isn't worth much. AI absolutely can make you worse. I've watched it happen, and I've done it. The mechanism is specific: you accept output you haven't read. That's it. That's the whole failure. Not "using AI" - accepting without reading. It's seductive because it works. The code runs. Nothing punishes you. You get a small hit of progress and you move on, and the debt is invisible because the thing you failed to learn doesn't announce itself. You only meet it later, usually at 11pm, when something breaks in a layer you never looked at. A developer in that loop

A coding agent can write syntactically plausible code and still leave a broken project behind. The obvious answer is to give the agent an lsp tool and let the model ask for diagnostics whenever it wants. SolonCode tried that shape first. The implementation put navigation and diagnostics in one tool, but diagnostics were effectively never requested. That result is not surprising: after a write, “check whether this introduced errors” is not an optional curiosity. It is part of the write operation’s feedback loop. SolonCode’s current design makes that distinction explicit: write and edit trigger diagnostics automatically after a successful change. read warms the language server asynchronously without delaying the read. The lsp tool is reserved for optional navigation such as definition, references, hover, symbols, and call hierarchy. The interesting engineering is not starting a language server. It is keeping the file, the language server, the model, and the Web UI consistent while all four observe different representations of the same change. Diagnostics should follow a write, not a model decision The implementation note in the repository describes the original failure plainly: ten capabilities—nine navigation operations plus diagnostics—were exposed through one tool, and diagnostics were “never called” in practice. That led to a three-layer design: write / edit / apply_patch -> sync the file -> wait for diagnostics -> append diagnostics to the tool output read -> warm up the language server asynchronously -> do not wait and do not change the read result lsp -> definition / references / hover / symbols / call hierarchy ... This is a useful rule for agent design: feedback that is necessary to evaluate a mutation belongs on the mutation path. Exploratory information can remain an explicit tool. The separation also keeps the tool schema smaller and the model’s decision burden clearer. The model does not need to remember a second call after every edit just to discover whe

DoorDash has moved engineering agent workloads from developer laptops to its Flux cloud platform. The platform automated 130,000 engineering tasks in one month and supports more than 25,000 automated code reviews weekly. Flux uses isolated Firecracker microVMs, an MCP gateway, reusable playbooks, and multiple invocation surfaces to run agent workflows with scoped access and centralized auditing. By Leela Kumili

Interactive mobile "gizmos" are easy to make, hard to share outside Meta's platform.

Amazon recently announced Kiro Crew, an open-source system for running multiple Kiro coding agents across sessions, tools, and tasks. The new workspace lets developers assign asynchronous coding tasks to AI agents, allowing work such as incident investigation, ticket triage, migrations, and PR monitoring to continue without active supervision. By Renato Losio

A branch came in for review with about sixty commits on it, every one authored by someone on the team. He hadn't written them. Claude Desktop had, running on his laptop, signing commits with the git identity we configured during setup. As far as the repository was concerned, the work was his. As far as blame, audit and every code-ownership convention we had, the work was his. Nobody could separate the four or five decisions he had actually looked at and accepted from the fifty-odd changes the model produced while he clicked through the result to see whether it worked. We moved the whole thing off his machine: the model runs server-side now, the working copy is provisioned per ticket in an isolated environment, and what comes back is a URL. That solved the port conflicts and the dependency drift, which was why we did it. It did not solve the attribution problem. It relocated it. Now a service account commits, and the service account is one identity shared by every run, for every person, on every ticket. That is the shape of the thing arriving at enterprises considerably faster than most access-management programmes are ready for. a new hire, a printer, and an agent Take a new hire in their first week. They have a unique identifier that will never belong to anyone else, a set of permissions somebody requested by name, a login trail, and an offboarding procedure that takes an afternoon. Four things: who they are, what they can reach, what they did, and how you get rid of them. Hiring, permissions, audit, firing. Now the printer on the third floor. It has an asset tag, it sits on a network segment that lets it reach the print server and nothing else, it logs every job, and you can unplug it. Same four things. Nobody is impressed by the printer, but the printer is fully accounted for. Now the agent your team stood up last month to triage tickets, read the CRM and post summaries into Slack. Who it is: it uses a key minted from a human account, probably belonging to whoeve

Hey DEV community! 👋 When debugging network streams, parsing custom file formats, or inspecting database buffers, we often extract data as raw arrays of numbers rather than human-readable text. This data typically presents itself as raw byte sequences formatted in either decimal or hexadecimal notation. While there are online decoders available, pasting raw byte sequences into third-party sites that process data on their backend databases introduces an unnecessary data privacy risk. To solve this, I designed a lightweight, entirely browser-based Byte to String Converter that decodes raw byte sequences locally using standard JavaScript APIs. In this post, we will look at how bytes map to character encodings and implement a client-side JavaScript utility to decode them safely. The Structure of a Byte In modern computing, a byte is the basic unit of digital information, consisting of an 8-bit sequence: 1 byte = 8 bits Because each bit represents a binary state (0 or 1), a single byte can represent: 2 8 = 256 states This translates to numeric values spanning from: Decimal (Base 10): Range of [ 0 , 255 ] Hexadecimal (Base 16): Range of [ 00 , FF ] When we render characters on a screen, we rely on character encoding tables (such as ASCII or UTF-8) to map these numerical byte values back to their original symbolic representations. Navigating Encodings: ASCII vs. UTF-8 The reconstruction process depends entirely on the encoding format used: ASCII: A basic 7-bit standard where each character maps to exactly one byte. It covers basic English letters, numbers, and core control characters. For example, the decimal value 72 maps to the uppercase letter 'H' . UTF-8: A variable-length encoding format that utilizes between 1 and 4 bytes per character. This structure allows UTF-8 to represent emojis, mathematical notations, and diverse language scripts. Our browser utility parses byte sequences using UTF-8 to maintain compatibility with modern web standards. JavaScript Implementatio

Vibecoding: How to Manage an AI Coder and Not Drown in Spaghetti Code Forget fairy tales about AI doing everything for you at the touch of a button. Without strict control, vibecoding quickly turns into a mess of broken, unmaintainable code. Modern vibecoding isn't blind generation — it is strict architectural supervision . To build real products, you must change your approach to context and redefine your role in the process. Forget Persona Prompting: Context is the Only King of Modern Prompting Fables like "Act as a Senior Developer" were left back in 2023. Modern LLMs don't need roleplay — they need the cleanest, deepest context possible . Why "Persona Prompting" is Outdated AI doesn't start coding better just because you called it a senior dev. It needs concrete technical boundaries. Skip the foreplay and provide the AI with technical specifications: Stack and versions: Not just "React", but React 18, Next.js 14 (App Router), Tailwind CSS . Architectural constraints: Show folder structure, naming conventions, and API response formats. Rule files ( .cursorrules / .clauderules ): Load strict rules into the project that the AI must follow at all times (e.g., "Never use any in TypeScript, write functional components only" ). Humans as Strict Regulators, Not Blind Consumers of Code The biggest danger of vibecoding is shipping AI-generated garbage straight to production without looking. If you blindly consume whatever the AI spits out, your project is doomed. 1. Total Quality Control and Code Review You act as the Technical Regulator and Censor . You never take the AI's word for it. Read every diff : Check exactly what the AI changes. Don't let it rewrite working modules from scratch just to add one button. Don't know how to code? Use basic logic: adding a single button shouldn't make 30 lines of code disappear from main.py or app.js . Force it to justify decisions: If the AI suggests a library, ask: "Why this one over a native solution? Will it impact performance?" 2.

Hey DEV community! 👋 When writing technical documentation, user guides, or long-form informational articles, maintaining a clear and engaging reading style is highly important. However, as writers, we often fall into repetitive phrasing habits without realizing it. Traditional word counters only track isolated, single words. To evaluate multi-word phrases and understand the flow of our writing, we need a different approach. This is where an N-gram analysis becomes highly useful. To provide a safe and private solution for content editors, I built a lightweight, entirely client-side N-gram Analyzer . In this post, we will explore the technical implementation of this utility, how to handle text segmentation in JavaScript, and why local browser processing is a reliable choice for data privacy. What is an N-gram? In computational linguistics and text processing, an N-gram is a contiguous sequence of $n$ items (usually words) from a given sample of text. A Unigram represents single words ($n=1$). A Bigram represents two-word phrases ($n=2$). A Trigram represents three-word phrases ($n=3$). A 4-gram represents four-word phrases ($n=4$). Analyzing these combinations helps developers and content creators identify repetitive phrases, evaluate vocabulary diversity, and check if the thematic distribution of a document aligns with its target focus. The Client-Side Approach: Privacy and Data Isolation Many online text tools process user inputs on backend servers. This setup introduces a significant privacy risk if you are analyzing sensitive internal documentation, unpublished drafts, or proprietary code comments. By executing the lexical parsing entirely within the user's browser, we keep the processing local. The text never travels across the network, and there are no external database logs. The local device handles the entire operation. Implementing the N-gram Extraction in JavaScript Let's look at the core logic. To build an N-gram extractor, the utility must perform three ke

I began this investigation with a specific question: can Codex autonomously add, modify, and delete its own memories? The product documentation already says that it has memory. What I wanted to know was who actually decides what survives. When an old chat contains a useful build command, does deterministic application code copy it into a database? Does the active coding model call a memory tool? Does another model summarize the chat later? When the command becomes obsolete, is the old fact overwritten, invalidated, aged out, or simply left where future agents may still find it? Those questions led to a more interesting result than a feature checklist. Codex has a genuine cross-session memory subsystem, but its behavior is split between model judgment and deterministic lifecycle code. Models decide what a rollout means and how durable guidance should be rewritten. Runtime code decides which rollouts are eligible, which evidence remains in the working set, when old records are deleted, and when the consolidation model is allowed to run. That makes the short answer precise: With local memories enabled, Codex can autonomously add, modify, merge, and remove persistent memory without a user approving each write. User-requested corrections follow a separate append-only note path, while retention, thread deletion, and reset provide additional forms of forgetting. The rest of this article explains why each word in that answer matters. This analysis is pinned to OpenAI Codex commit 8444cf63b50a8a88521e0d2970d49f659b48eac7 , checked on August 25, 2026. The feature is marked stable in that source tree but remains off by default, so this describes implemented behavior, not behavior every Codex user is currently receiving. Key Takeaways Codex local memory is a background two-model pipeline. One model extracts reusable material from each eligible rollout. A second model consolidates those outputs into a global file-based memory workspace. The LLM owns semantic CRUD, but not lifecy

Hey DEV community! 👋 As developers, we handle Base64 encoding and decoding almost daily—whether we're debugging API payloads, formatting authorization headers, or embedding small graphic assets directly into stylesheets. However, many online translation utilities process your inputs on their backend servers. If you are dealing with sensitive configuration parameters, internal logs, or keys, pasting that data into a third-party web tool is a clear data privacy risk. To solve this, I decided to "vibe-code" a lightweight, strictly browser-based, privacy-oriented Base64 Encoder & Decoder . In this post, we will look at how this utility was built using AI assistance and vanilla JavaScript, along with the core logic to handle common encoding pitfalls. What is "Vibe Coding"? For those unfamiliar with the term, vibe coding is the practice of leveraging modern generative AI models to handle the bulk of the standard layout and event listeners, while you focus on the core logic, user experience, and privacy requirements. Instead of writing every CSS class and event listener manually, I guided an AI assistant to generate a clean, responsive layout using a standard grid framework, while ensuring that the core translation logic resides strictly in the user's browser. The Pitfall of Traditional JS Base64 (and How to Fix It) If you have ever used native JavaScript btoa() and atob() functions, you might know they struggle with Unicode/UTF-8 characters (like emojis or non-Latin scripts). Running this in your console will throw an error: btoa ( " Xin chào! 🚀 " ); // Throws "Uncaught DOMException" To resolve this during the development process, the utility implements modern TextEncoder and TextDecoder APIs. This approach converts strings into binary byte arrays before encoding them, avoiding exceptions. The Client-Side Implementation Here is the clean JavaScript snippet used for bidirectional encoding and decoding: function processBase64 ( action , inputValue ) { try { if ( action ===

A polished UI can make a product feel completely different, but getting there usually takes more than...

AI coding agent Cursor has launched Origin, a git based code hosting platform embedded inside its AI-powered editor, positioning it as an alternative to GitHub for teams that already work in Cursor. Origin is rolling out in early beta on Pro, Teams and Enterprise plans, and lives inside a new Codebase tab within the Cursor application. By Matt Saunders

I started this investigation after finding a local OpenCode project that appeared to remember guidance across sessions. The guidance lived in Markdown files outside the repository, yet every new session followed it. The operational question was simple: had OpenCode decided to preserve those facts, or had someone explicitly written them? The session record answered it. An agent had created the files through an ordinary file tool after an explicit user request. A project-local instructions configuration then loaded them on every provider turn. What looked like autonomous memory was user-triggered file authoring plus deterministic prompt injection. That result sent me looking for the actual memory subsystem. There is no general runtime-managed service that decides what to save, updates facts when they change, and semantically retrieves useful knowledge in later sessions. What users experience as "memory" is produced by three different mechanisms with different owners and failure modes: instruction files are loaded into the system prompt, durable session events and projected messages are persisted in SQLite, and old model-visible context is replaced by a generated compaction checkpoint when the request grows too large. These mechanisms work together, but they do not form an autonomous long-term memory manager. That distinction matters. If a coding agent remembers a project rule because AGENTS.md is injected on every turn, that is not learned memory. If it can reopen an old transcript from SQLite, that does not mean a new session can retrieve facts from it. If a long session survives by summarizing its history, that does not mean the runtime selected the most important information. This article follows the current OpenCode source tree, which contains both the desktop-compatible session path under packages/opencode and the newer V2 runtime under packages/core . Where the two paths differ, I call out the difference rather than treating them as one implementation. Primary c

Shift-left and DevOps have impacted how we flow changes from inception to production, but at the cost of increased cognitive load and duplication of effort across testing, security, and maintenance. This article explores the real-world challenges of rightsizing developer platforms and finding a cultural match for engineering teams who use them to reduce cognitive load and deliver change faster. By John Keates

Question : Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers. If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order). The replacement must be in-place and use only constant extra memory. Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column. Example : 1,2,3 → 1,3,2 3,2,1 → 1,2,3 1,1,5 → 1,5,1 Idea : Scan from right to left and find the first element that is less that its previous. eg: 1 6 3 5 -> here it is 3. Let's name it as index. Again scan from right to left and find the first element that is greater than 3 and that's 5. Let's mark it as idx. 3.In this step we swap 3 and 5. Reverse elements from index+1 till the array length. Code: public void nextPermutation(int[] nums) { int index = -1; for(int i=nums.length-1;i>0;i--){ if(nums[i]>nums[i-1]){ index = i-1; break; } } if(index==-1){ reverse(nums,0,nums.length-1); return; } int idx=0; for(int i=nums.length-1;i>=index+1;i--){ if(nums[i]>nums[index]){ idx=i; break; } } swap(nums,index,idx); reverse(nums,index+1,nums.length-1); } void swap(int[] nums,int i,int j){ int temp =nums[i]; nums[i] = nums[j]; nums[j] = temp; } void reverse(int[] nums,int i ,int j){ while(i<j){ swap(nums,i,j); i++; j--; } } Code Explanation : We first initialize index=-1 and traverse backward to find the first one with i that satisfy the condition nums[i]>nums[i-1] . We assign this to index and break out of the loop. for(int i=nums.length-1;i>0;i--){ if(nums[i]>nums[i-1]){ index = i-1; break; } } Next step we are discussing a corner case. For example if the given array is 3,2,1 then we cannot find the element that satisfies the previous condition. So when the array is given in decreasing order we just reverse it and return. if(index==-1){ reverse(nums,0,nums.length-1); return; } Next iteration we are considering another variable idx and traverse backw

This is a simplified guide to an AI model called Beat_this maintained by Xavriley . If you like these kinds of analysis, you should join AImodels.fyi or follow us on Twitter . Overview beat_this is a beat and downbeat tracking model from the ISMIR 2024 paper "Beat This! Accurate Beat Tracking Without DBN Postprocessing" by xavriley and collaborators at CPJKU. The model detects precise beat positions and downbeat boundaries in audio files without relying on Dynamic Bayesian Network postprocessing, achieving state-of-the-art F1 scores while maintaining generality across diverse music genres. The architecture alternates convolutions with transformers operating either over frequency or time dimensions, and is trained on multiple datasets including solo instruments, pieces with time signature changes, and classical music with high tempo variations. The main model ( final0 , final1 , final2 ) weighs approximately 78 MB each, with a smaller variant available at 8.1 MB. The most critical detail before using it: the model achieves good results specifically because it avoids meter and tempo constraints that traditional systems impose, but this means it can still fail on difficult and underrepresented genres and performs worse on continuity metrics compared to methods using postprocessing. Best use cases Music information retrieval and analysis workflows. If you build music analysis software that needs to segment tracks into beat-aligned sections for tempo detection, structural analysis, or synchronization with other modalities, beat_this provides clean beat and downbeat annotations without requiring external postprocessing pipelines. The model outputs precise timestamps suitable for downstream music information retrieval tasks like onset detection or harmonic analysis. Rhythm-aware music production tools. For digital audio workstations, beat detection plugins, or metronome applications, this model provides frame-level accuracy suitable for real-time audio alignment and grid s

I Built a Python Bot That Plays Blackjack on Discord's OwO Bot 🃏 An automation experiment in game logic, human-like timing, and why the house still wins. ⚠️ Disclaimer first: This project is for educational purposes only . It's a coding experiment about automation, pacing, and basic blackjack strategy. I'm not promoting gambling, I'm not responsible for any losses, and self-bots can violate Discord's Terms of Service — know the rules before running anything like this. What is this thing? If you've spent time in Discord economy servers, you've probably met OwO Bot — one of the most popular Discord bots out there, with its own cash economy and gambling minigames, including Blackjack . I asked myself a fun engineering question: Can I write a Python client that plays full Blackjack sessions on its own — with human-like pacing, break cycles, and a sensible betting strategy? That experiment became GhoSty OwO BlackJack Farm — a Python-based Discord self-bot focused on OwO Bot's Blackjack, now at V2.1 . What it does 🔄 Full Blackjack automation — handles the game loop end-to-end. 💡 Smart betting — strategy-based decisions instead of random yolo bets. 😴 Smart Sleep — lifetime work/break cycles instead of 24/7 spamming. ⏱️ Dynamic gaps — randomized delays between every action. 🚨 Zero win guarantees — on purpose. More on that below. The stack (and why an old discord.py) Python 3.10+ discord.py==1.7.3 colorama Yes, 1.7.3 is ancient — deliberately. The self_bot=True pattern that this kind of client relies on was removed in newer discord.py versions, so legacy 1.7.3 is the line that still supports it. If you've never touched pre-2.0 discord.py, this project is a small time capsule of that API. The whole project is intentionally tiny: OwO-Blackjack-Farm/ ├── main.py # bot + game logic ├── config.json # your token & settings ├── requirements.txt └── README.md Setup is two steps: drop your token into config.json , then: pip install discord.py == 1.7.3 colorama python main.py Start it

Enterprise vibe coding: the governance framework for shipping AI-generated apps to production Published: August 22, 2026 Category: Enterprise · AI Deployments Reading time: 9 minutes Author: NEXUS AI Team Gartner forecasts that 40% of new enterprise production software will be built using vibe coding techniques by 2028. A 2026 scan of more than 1,400 live vibe-coded applications found that 65% already had a security issue, and 58% shipped with at least one critical vulnerability. Those two numbers describe the same industry moving in opposite directions at once: adoption is outrunning governance. This post covers what a governance framework for enterprise vibe coding actually looks like, the five controls it needs, and where most teams get it wrong. What is enterprise vibe coding? Enterprise vibe coding is the practice of using natural-language prompts to generate application code, then governing that code through mandatory review, access control, and audit before it reaches production, rather than letting it ship straight from a prompt to a live endpoint. The term (coined by Andrej Karpathy in early 2025) originally described a fast, low-friction way for one person to build a prototype. What "enterprise" adds is the governance layer prototyping was never built for: staging environments, encrypted secrets, role-based access, and a record of who approved what. That distinction matters because the adoption curve and the risk curve are not moving together. The governance gap, in three numbers 40% of new enterprise production software will be built using vibe coding techniques by 2028, according to Gartner's May 2025 report "Why Vibe Coding Needs to Be Taken Seriously," as reported by CIO Dive . 65% of vibe-coded production applications had a security issue, in a 2026 scan of more than 1,400 live apps by the API security firm Escape.tech, reported via a Cloud Security Alliance research note . 58% of those same applications shipped with at least one critical vulnerabilit