software engineering tasks which may take humans weeks seem to be within reach for AI systems.

An engineer at Cloudflare used Claude with OpenCode to release vinext, a reimplementation of Next.js on Vite, for only ~$1,100 in API costs.

Most passing SWE-Bench solutions are not accepted by maintainers.

Still, the psychologist argues, “there’s no longer an excuse for releasing models that reinforce user delusions so readily.” “When one lab’s models can largely maintain safety across extended conversations, while others are willing to validate extremely harmful outcomes — up to and including a user’s suicidal ideation — it suggests this isn’t a flaw in the technology,” said Nicholls, “but a result of specific engineering and alignment choices.”

The one real underlying asset, Workday's trillion-transaction dataset, is thinner than it sounds; what actually matters at runtime is how data connects to workflows, permissions, and integrations, and every layer of that stack is now a liability.

When customers renew at close to 100% every year, it's usually read as a sign the product is delightful. In Workday's case, it's a sign of something else: leaving is close to impossible.

Our early versions of agentic work was only asking Codex to implement the task. That approach proved too limiting. Codex is perfectly capable of creating multiple PRs as well as reading review feedback and addressing it.

Six months ago, while working on an internal productivity tool, our team made a controversial (at the time) decision: we'd build our repo with no human-written code. Every line in our project repository had to be generated by Codex.

The fix is not smarter prompts. It is software built to meet agents halfway.

The fix is not smarter prompts. It is software built to meet agents halfway.

In other words, COSMIC behaves more like a collection of coordinated tools than a single monolithic environment. This makes the system easier to evolve over time. Components can be updated or replaced without rewriting the entire desktop. It’s a surprisingly modern design philosophy for a Linux desktop environment, and it’s one of the reasons many developers are watching COSMIC closely.

By customizing and co-designing silicon with hardware, networking and software, including model architecture and application requirements, we can deliver dramatically more power efficiency and absolute performance.

We spent days loading the system with hundreds of threads, refining rough edges and polishing corners that developers may never see.

What we've found works best for crafting high-quality software is somewhere in between: using AI, and also engaging directly with code.

Zig distributes its toolchain as a Python package, which is built on the assumption that virtually all computers already have a Python distribution of some kind.

AI writes the code. Tests verify correctness. More code enables more features.

More code enables more features. Companies will always need more software

There were 1 billion commits in 2025. Now, it's 275 million per week, on pace for 14 billion this year if growth remains linear

On the SWE-Pro benchmark, M2.7 scores 56.22%, nearly matching Opus's best level.

M2.7 demonstrates excellent performance in real-world software engineering, including end-to-end project delivery, log analysis for bug hunting, code security, and machine learning tasks.

On the SWE-Pro benchmark, M2.7 scores 56.22%, nearly matching Opus's best level.

Four researchers and software engineers estimated that a skilled human engineer would take 2 to 17 weeks to reimplement gotree, as AI successfully did in this work.

It is not common for real software to be developed the way MirrorCode tasks are structured — against a precise, programmatically checkable specification.

Claude Opus 4.6 autonomously reimplemented a 16,000-line bioinformatics toolkit — a task we believe would take a human engineer weeks.

GLM-5.1 achieves state-of-the-art performance on SWE-Bench Pro and leads GLM-5 by a wide margin on NL2Repo (repo generation) and Terminal-Bench 2.0 (real-world terminal tasks).

Xcode should ship with a built-in MCP that handles auth when an LLM connects to a project. Notion should have `mcp.notion.so/mcp` available natively, instead of forcing me to download `notion-cli` and manage auth state manually.

When a remote MCP server is updated with new tools or resources, every client instantly gets the latest version. No need to push updates, upgrade packages, or reinstall binaries.

Being open source is increasingly like giving attackers the blueprints to the vault. When the structure is fully visible, it becomes much easier to identify weaknesses and exploit them.

There was a time that whenever you looked at search results on Google, you could click the "Cached" button to view an archived version of the page. Unfortunately, Google has decided to remove the feature. The company's stated reason is that the feature was created to allow users a way to see the content at a time when sites would go offline frequently, and that the basic functionality of the internet has improved to the extent that it's no longer necessary. Whatever the reason, it means yet another useful feature has found itself in Google's graveyard.While Google may profess that feature isn't relevant any longer, that's not the case. Posts are deleted all the time, link rot is very real, and entire sites are regularly purged from existence Any time you want to access a post that has been removed due to corporate or political censorship, you now have one less tool to see what was published. Google's cache was also among the most reliable ways to access pages that would take a long time to load or keep going down frequently, something that still happens with smaller blogs or with sites run by the government in plenty of regions in the world.Any time a web page failed to work as expected, you could easily access Google's cache directly from the search results, but that button has now been removed—if not the functionality itself. Because at the time of this writing, there remain a few easy workarounds that allow you access Google's cached webpages.

Obsidian is the IDE; the LLM is the programmer; the wiki is the codebase.

You don’t realise how slow/laggy VSCode and the all of the forks are until

Implicit state is the Enemy

This class of bug is insidious because it evades every layer of defense. It will not be caught in development testing — who runs a test for 50 days? It will not be flagged in code review — the logic looks perfectly reasonable.

Looking at the code and having opinions on architecture is seen as just as 'bad' as calling a compiled C module from an interpreted language was seen back in the day... it's not bad, it's actually quite practical, but it violates some strange 'purity'.

Bad software is a decision you make. You need to own it. You should do better.

Looking under the hood is cheating. You're only supposed to have vague conversations with the machine about what it's doing.

This means 2.7x more tokens from the same GB300 NVL72-based infrastructure and power footprint, reducing the cost to manufacture each token by more than 60%.

TAM posits that the intention to adopt a particular technology is driven by two kinds of perceptions: (1) how easy it is to use a system and (2) how useful it will be to use it [180]. Furthermore, the perceived ease of use affects the perceived usefulness: If technology is hard to use, it is less useful.

it is perfectly possible to have a program which is structured, modular, readable, flexible, self-documenting, maintainable, which performs its specified function, and which is a source of constant frustration and irritation to its users.

The theory of task–technology fit (TTF) can illuminate what users consider useful and how this affects their decision to adopt a particular technology. TTF refers to the ability of technology to support a task [197]. The capabilities of the technology should match the demands of the task and the skills of the individual; in this case, the fit is perfect.

Users actively repurpose tools to make them more personally usable and relevant. Design should support such repurposing. For example, Renom et al. [696] conducted a study on text editing using a novel user interface. They found that exploration and technical reasoning facilitate creative tool use.

One prominent definition of accessibility is given by ISO 9241-171, which defines it as 'the usability of a product, service, environment or facility by people with the widest range of capabilities.'

The second dimension, social acceptability, concerns whether interactions map well to the social norms and roles in the settings where they occur.

Acceptability has two main dimensions [591]. The first dimension, practical acceptability, includes costs, the reliability of the interactive system, and its compatibility with other systems. The perceptions of utility and usability may also influence the judgment of practical acceptability.

usability is multidimensional. This means that in most settings, a valid characterization of usability will need to employ several dimensions and measures.

usability is measurable, that is, it is possible to quantify usability based on users' behaviors or opinions.

usability is relational; it arises as an interplay between people, tasks (problems), and interactive systems (tools)

ISO 9241-11 definition... defines usability as the 'extent to which a system, product or service can be used by specified users to achieve specified goals with effectiveness, efficiency and satisfaction in a specified context of use.'

One shorthand way of expressing this is that utility is 'whether the functionality of a system in principle can do what is needed' [591, p. 25]. In practice, whether people can do anything concerns—among other things—usability.

The utility of an interactive system concerns its match with the tasks of users. If the match is good, the tool has high utility; if the tasks that users want to do are not supported by the tool, the tool has low utility.

Usability concerns how easily computer-based tools may be operated by users trying to accomplish a task. Usability differs from utility. Usability concerns whether users can use the product in a way that makes it possible to realize its utility; utility is about whether the goal is important to the user. Ideally, the user can use the tool without unnecessary effort so that the use is direct, transparent, and unnoticeable.

Usability is one of the best predictors of users' willingness to adopt software. For example, the User Burden Scale is a questionnaire for measuring the felt burden in software use [806]. It consists of six subscales: difficulty of use, physical burden, time and social burden, mental and emotional burden, privacy burden, and financial burden.

The unofficial API authenticates using your actual Sunsama email and password. So my serverless function needs to store my real credentials.

I've skimmed Crafting Interpreters and the Bytecode VM section seems to spend an inexplicable amount of time on not only parsing, but minutia having nothing to do with compilers (e.g. writing a custom dynamic array implementation in C).

We envision a component generator with knobs thatlet a user choose among design decisions, akin to sim-ilar work for code generation from design patterns [1].Such a tool is sufficiently parameterized to generateany combination of implementation trade-offs on thespectrum from fully static to fully dynamic compo-nents. The components that result can thus exhibitjust the right combination of flexibility, maintainabil-ity, and performance, with a minimum of specificationand hackery on the developer’s part.

for me, a software component is a reusable software element, typically some library classes, usually in source form (not binary form), which differs from Clemens Szyperski’s view

code of view wasn't about catching bugs. It was a primary mechanism for knowledge transfer. When your engineers learn architecture by reading senior engineer PRs, seniors maintain context by reviewing everything, and code of view was the learning loop. It was how shared theory was built and maintained across the entire team. But AI bypasses that entire loop. The code shows up, it works, it gets merged, but nobody learned anything. Nobody built context. Nobody can debug at a 3AM without reprompting the AI. And code of view was never about catching bugs. It was always about building shared understanding. AI skipped the most important step.

Feudalismo

most front-end developers have normalised doing daily trust falls with their codebases

Lua is more dynamic than Wren which makes its job harder. Lua also tries very hard to be compatible across a wide range of hardware and compilers. If you have a C89 compiler for it, odds are very good that you can run Lua on it. Wren cares about compatibility, but it requires C99 or C++98 and IEEE double precision floats. That may exclude some edge case hardware, but makes things like NaN tagging, computed gotos, and some other tricks possible.

Languages come in four rough performance buckets, from slowest to fastest

And when you work with a team, you are stuck anyway with the worst possible tool that satisfies the need of the dumbest member of the team. Usually the manager.

Commercial software whose source code you were legally prohibited from reading was “antithetical to the idea of science,” where the very purpose is to open the black box of nature.

This makes questions like “how fast is WebAssembly” a bit hard to answer. You don’t ask how fast algebraic notation is—it’s not a very sensible question. Taken in the context of something like JavaScript, the language is only as fast as the engine running it. JavaScript the language has no speed, but you can benchmark JS engines like V8, SpiderMonkey, and JavaScriptCore. You can benchmark the IO libraries of JS runtimes like Bun, Deno, and Node. What people actually mean is “how useful are the constructs of this language to efficient mappings of modern hardware” and “what is the current landscape of systems taking advantage of these constructs”.

We’re bringing a social experience to Anytype by making spaces more interactive. We start with the concept of one space = one group = one chat. Then we’ll expand to include discussions on objects, enabling forum-like use cases. It will significantly improve collaborative use cases. You’ll chat and discuss your pages and files in the same end-to-end encrypted and local-first way.

Koha Library Software The world's first free and open source library system

Most complex software ships with a few bugs. Obviously, we want to avoid them, but the more complex a feature is, the harder it is to cover all the use-cases. As we get closer to our RC date, do we feel confident that what we're shipping has as few blocking bugs as possible? I would like to say we're close, but the truth is I have no idea. It feels like we'll have to keep trying the features for a bit until we don't run into anything - but we have less than 3 weeks before the RC ships. Here's a few surprising bugs that need to get fixed before I would feel comfortable shipping node12 in stable.

One pattern that I love to use in my SvelteKit projects is returning writable stores from the layout’s load function. This makes it possible to fetch data from the server (for example the user object for the logged in user), and then you make this object available as a writable reactive store throughout the whole application. So when the user updates their username or avatar, you do the PUT request to the server and you get the updated user object back from the server as the response, you can simply update the $user writable store value and every place in your app where you show the user object gets updated immediately.

Another limitation in this implementation is that passing other options in the shebang to vite-node won't work, as I expect exact indexes in order to figure out what are the arguments to forward. It's not perfect but I think it's good enough to unblock people like me as a start. 👍

los documentos como aspectos separados y encerrados de nuestra experiencia de cómputo

los documentos como aspectos separados y encerrados de nuestra experiencia de cómputo

los documentos como aspectos separados y encerrados de nuestra experiencia de cómputo

Many in Silicon Valley believe we're less than a year away from AI that can automate most software engineering work

Vite's job is to get your source modules into a form that can run in the browser as fast as possible. To that end, we recommend separating static analysis checks from Vite's transform pipeline.

Vite uses esbuild to transpile TypeScript into JavaScript which is about 20~30x faster than vanilla tsc, and HMR updates can reflect in the browser in under 50ms.

Above: the time to do a production bundle

However, I also feel that Ruby sometimes seems too focused on being backwards compatible, to a point where it risk hurting the ecosystem. I think this thread is a good example, because it seems like such a small and benign change, yet it's taken several years and lots of back and forth, and in the end the proposed change wasn't even applied(!?).

With its "no downstream hacks" and "upstream first" approach, it acts as a cutting-edge catalyst to push open-source technologies we love forward.

Simply choosing a more efficient programming language speeds up this calculation

but once I got some momentum there, I switched to Krita and never looked back. Looking back I’d just skip Corel and start with Krita

Why is more important than how

Everything is a trade-off

Software architecture choices include specific structural options from possibilities in the design of the software.

The software design model can be compared to an architected plan for a house. High-level plans represent the totality of the house (e.g., a three-dimensional rendering of the house). Lower-level plans provide guidance for constructing each detail (e.g., the plumbing lay). Similarly, the software design model provides a variety of views of the proposed software solution.

including both high-level software architecture and low-level component and algorithm design.

The first one is about using the code artefacts (classes, variables, modules, …) names to convey both domain and architectural meaning.

“[…] an architecturally evident coding style that lets you drop hints to code readers so that they can correctly infer the design.”

Another problem is that now your business logic is obfuscated inside the ORM layer. If you look at the structure of the source code of a typical Rails application, all you see are these nice MVC buckets. They may reveal the domain models of the application, but you can’t see the Use Cases of the system, what it’s actually meant to do.

We are destroying software mistaking it for a purely engineering discipline.

Open source technology, now responsible for 80% of all used software

There is a tremendous power in thinking about everything as a single kind of thing, because then you don’t have to juggle lots of different ideas about different kinds of things; you can just think about your problem.

Free software means that the users have the freedom to run, edit, contribute to, and share the software

We can't compete with Apple, we can't compete with Google, directly, in the field of resources. What we can eventually do is head count and heart count. We can compete on the ground of ideology because ours is better.

Arbib and Seba explain this by categorising human civilisation into two fundamentally intertwined complexes: the production system, encompassing all the foundational systems by which we meet fundamental material needs across energy, transport, food and materials (corresponding to ‘hardware’); and the organising system, encompassing how the former systems are governed, regulated and managed by society through economic, political, military, cultural and ideological structures and values (corresponding to ‘software’)

The ‘hardware’ is a configuration of matter which harnesses energy from its environment with surprising efficiency and dissipates it as waste back into the environment.

If one profiles what is going on in this whole process, it becomes clear that I/O dominates. Of the cpucycles expended, most go into conversion to and from intermediate file formats.

Built in the open Concourse's RFC process and governance model invite anyone to become a contributor, developing the project roadmap by collaborating in the open.

GPL "infects" other parts of a system to combat a work-around which was used to violate the software freedom of the user, by firewalling sections of GPL'ed code from the rest of the system.

The point of GPL licenses is to protect the user of the software, not the developer. If you want "protection" as a developer, use MIT (disclaimer of warranty). GPL "infects" other parts of a system to combat a work-around which was used to violate the software freedom of the user, by firewalling sections of GPL'ed code from the rest of the system. If you don't care about your users' software freedom in the first place, then (L)GPL is the wrong choice.

A free program allows you to tinker with it to make it do what you want (or cease to do something you dislike). Tinkering with software may sound ridiculous if you are accustomed to proprietary software as a sealed box, but in the Free World it's a common thing to do, and a good way to learn programming. Even the traditional American pastime of tinkering with cars is obstructed because cars now contain nonfree software.

If any of them is missing or inadequate, the program is proprietary (nonfree)

With all four freedoms, the users fully control the program.

With the other two freedoms, any group of users can together exercise collective control over the program.

Users' control over the program requires four essential freedoms.

freedom to study the program's “source code,” and change it, so the program does your computing as you wish

freedom to run the program as you wish, for whatever purpose.

The first two freedoms mean each user can exercise individual control over the program

Either way, they give the program's developer power over the users, power that no one should have.

When a program respects users' freedom and community, we call it “free software.”

computer users' freedom—for users to control the software they use, rather than vice versa