Sr. Content Developer at Microsoft, working remotely in PA, TechBash conference organizer, former Microsoft MVP, Husband, Dad and Geek.
165475 stories
·
33 followers

Trump Admin Still Won't Let TP-Link Sell Routers In US

1 Share
An anonymous reader quotes a report from Ars Technica: TP-Link, which may be the top provider of wireless routers for US homes and small businesses, isn't allowed to sell its latest Wi-Fi routers in the US. The Trump administration imposed a sweeping ban on foreign-made consumer routers in March 2026, and TP-Link hasn't been able to obtain an exemption. The rules prevent the import or sale of all new router models that are manufactured, assembled, designed, or developed outside the US. The Trump administration has control over which router makers receive special permission to import and sell new products through a waiver-review process involving the Federal Communications Commission, the Department of Defense, and the Department of Homeland Security. While some of its competitors have obtained exemptions to the ban, TP-Link appears to be having a hard time making its case to government officials. Its routers approved before the March 2026 ban remain available for sale in the US, but its newly released Wi-Fi 8 routers cannot be imported or sold. Earlier this year, TP-Link announced plans to begin assembling routers in Mississippi as early as 2027, "but convincing Trump officials that it is fully under US control is likely a difficult task," reports Ars. "The government reviews of router makers' requests for waivers, formally called conditional approvals, are shrouded in secrecy."

Read more of this story at Slashdot.

Read the whole story
alvinashcraft
20 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

181: Tesla Invites Cybercab Buyers at $29,990, But Also Bills $299 a Month

1 Share
In this episode:
● Tesla opens Cybercab orders to select buyers: $29,990 plus a $299 monthly subscription
● Aptera finishes its first customer solar EV, and it’s headed overseas
● GM EV owners can now plug in and charge at Electrify America with no app or card
● Much much more

Get pre-approved for your EV loan at Clean Energy CU: https://sl.cleanenergycu.org/cevlo

Host:
Martyn Lee from ev.news
https://www.ev.news/pod

Cohosts:
Tom Moloughney from State of Charge and EVchargingstations.com
https://evchargingstations.com/ |   / stateofchargewithtommoloughney 
Domenick Yoney from Drive Electric With Domenick
  / @driveelectricwithdomenick 

Guest:
Patrick Anderson from The Electric Duo
  / @theelectricduo 

Thank you for your support! https://buymeacoffee.com/batteriesinc...




Download audio: https://dts.podtrac.com/redirect.mp3/audioboom.com/posts/8979608.mp3?modified=1795206294&sid=5141110&source=rss
Read the whole story
alvinashcraft
21 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Copilot Code Reviews for Azure Repos is generally available

1 Share

Today, we’re announcing the general availability of Copilot Code Review for Azure Repos, bringing the power of GitHub Copilot to Azure DevOps.

Thank you to everyone who participated in the private preview in June and the public preview in August. Your feedback helped us improve the experience and prepare for general availability.

With Copilot Code Reviews, teams can use Copilot to review pull requests in Azure Repos, identify potential issues, and suggest code changes before the code is merged.

Here’s how to get started.

Enable Copilot Code Review

Organization administrators can enable Copilot Code Review under Organization settings > Repos > Repositories.

You can enable it across all projects and repositories or allow project and repository administrators to manage their own settings.

blog enable ccr on org image

All configuration changes are recorded in the Azure DevOps audit log, so administrators can track where Copilot Code Review is enabled and who made changes.

blog audit log image

Configure reviews for your team

You can customize how Copilot reviews code based on your team’s needs.

Custom instructions let you define coding standards and review guidelines. You can apply them at the organization, project, or repository level. You can also reference skills in your custom instructions.

Effort levels control how thoroughly Copilot reviews a pull request. You can set Lite or Balanced as the default for a project or repository, or choose a different level for an individual review. Lighter reviews use fewer credits and cost less.

blog instructions image

Automatic reviews let you run Copilot on every pull request, including drafts. Add a branch policy to the target branch, and Copilot will automatically review new pull requests.

Request a review

Open a pull request and select Request next to GitHub Copilot in the Reviewers section.

Copilot adds comments to lines where it identifies potential issues. When possible, it also provides suggested changes that you can apply with one click.

blog ccr image

After applying and committing suggestions, you can resolve the related comments together instead of resolving each one individually.

Copilot does not approve pull requests or block merges. Your team remains responsible for reviewing and approving code.

Billing and cost management

Copilot Code Review uses usage-based billing, with charges billed to the Azure subscription linked to your Azure DevOps organization. Each review consumes tokens that are converted into GitHub AI credits at a rate of $0.01 USD per credit. The cost depends primarily on the size of the pull request and the selected effort level.

Charges appear as a separate meter in Azure Cost Management. They also include Azure DevOps project tags, so you can filter or group costs by project and see which teams are driving usage.

You can also set budget alerts for Copilot Code Review, including alerts for specific projects. Azure will notify you by email when actual or forecasted spending reaches a threshold you define.

We recommend starting with one or two repositories and monitoring usage and costs before rolling out more broadly.

What’s next

As much as we are excited to announce Copilot Code Reviews as generally available, we still have work to do. You can track the up and comings features on the public roadmap.

Get started today

Copilot Code Review is now generally available for Azure Repos. Enable it for your team, try it on your next pull request.

For more information, see the Copilot Code Review documentation and billing FAQ.

The post Copilot Code Reviews for Azure Repos is generally available appeared first on Azure DevOps Blog.

Read the whole story
alvinashcraft
21 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Can C# 15 Union Types Replace the Result Pattern?

1 Share

Yes, C# 15 union types can replace the Result pattern. A generic union Result<T>(T, Error) works like the Result class, and a validation decorator still works with it. To have the compiler catch a new failure, give each failure its own type in a union and wrap it in a generic Outcome<T, TError>.

I've returned expected failures with the Result pattern for years. Instead of throwing an exception, a method returns an object that holds either a value or an Error.

In May, I gave you a quick tour of union types while they were still in preview. Now they've shipped with C# 15 and .NET 11.

So I took one of my use cases and rewrote it with a generic union. Then I added a new failure to see what the compiler catches.

The Use Case With a Result

The use case reserves an apartment for a range of dates. The command carries the apartment and the two dates:

public sealed record ReserveBooking(Guid ApartmentId, DateOnly Start, DateOnly End);

It can fail in two ways: the apartment doesn't exist, or the dates are already taken.

With the Result pattern, each failure is an Error. An Error has a Code that identifies the failure and a Description for humans. The codes are constants, and the errors live in static classes, one per entity, so every handler reuses the same instances:

public sealed record Error(string Code, string Description);

public static class ErrorCodes
{
    public const string ApartmentNotFound = "Apartments.NotFound";
    public const string Overlap = "Bookings.Overlap";
}

public static class ApartmentErrors
{
    public static readonly Error NotFound = new(
        ErrorCodes.ApartmentNotFound, "The apartment was not found");
}

public static class BookingErrors
{
    public static readonly Error Overlap = new(
        ErrorCodes.Overlap, "The apartment is already booked for these dates");
}

The handler returns a Result<Guid>. It's the Result class from the Result pattern article: it holds either the new booking's id or an Error, and IsSuccess tells you which one.

public async Task<Result<Guid>> Handle(ReserveBooking command)
{
    Apartment? apartment = await store.GetApartmentAsync(command.ApartmentId);

    if (apartment is null)
    {
        // A failure is wrapped in a Result.
        return Result.Failure<Guid>(ApartmentErrors.NotFound);
    }

    if (await store.IsOverlappingAsync(apartment, command.Start, command.End))
    {
        return Result.Failure<Guid>(BookingErrors.Overlap);
    }

    var booking = Booking.Create(apartment, command.Start, command.End);

    store.Add(booking);

    // An implicit conversion turns the Guid into a successful Result<Guid>.
    return booking.Id;
}

A Minimal API endpoint calls the handler and turns the result into an HTTP response. On success it returns 201 Created. On failure it maps each error code to a status code:

app.MapPost("/bookings", async (ReserveBooking command, ReserveBookingHandler handler) =>
{
    Result<Guid> result = await handler.Handle(command);

    if (result.IsSuccess)
    {
        return Results.Created($"/bookings/{result.Value}", result.Value);
    }

    // Match the error code against the known constants.
    return result.Error.Code switch
    {
        ErrorCodes.ApartmentNotFound => Results.NotFound(result.Error),
        ErrorCodes.Overlap => Results.Conflict(result.Error),
        // Any other code
        _ => Results.Problem(result.Error.Description)
    };
});

Code is a string, and a string can hold any value. So the switch needs the _ arm, and Results.Problem turns a code the endpoint doesn't know into a 500.

Keep that _ arm in mind. It's where a new failure ends up later.

The Result Pattern as a Generic Union

A union is a type that holds exactly one value from a fixed list of types. Those types are its case types. You declare a union with the union keyword and list the case types in parentheses.

Result<T> is generic, and a union can be generic too:

// Holds either a T (the success value) or an Error (the failure).
public union Result<T>(T, Error);

For Result<Guid>, the case types are Guid and Error. Error is the same record as before, with its code and description. There's no IsSuccess flag: the type of the value inside tells you whether the call succeeded.

The compiler generates a conversion from each case type to the union. So the handler returns the Error or the Guid as it is, and Result.Failure<Guid>(...) goes away:

public async Task<Result<Guid>> Handle(ReserveBooking command)
{
    Apartment? apartment = await store.GetApartmentAsync(command.ApartmentId);

    if (apartment is null)
    {
        // Error converts to Result<Guid>.
        return ApartmentErrors.NotFound;
    }

    if (await store.IsOverlappingAsync(apartment, command.Start, command.End))
    {
        return BookingErrors.Overlap;
    }

    var booking = Booking.Create(apartment, command.Start, command.End);

    store.Add(booking);

    // Guid converts to Result<Guid>.
    return booking.Id;
}

The endpoint reads the result with one switch expression. Each arm is a pattern that checks the type of the value inside the union:

app.MapPost("/bookings", async (ReserveBooking command, ReserveBookingHandler handler) =>
{
    Result<Guid> result = await handler.Handle(command);

    return result switch
    {
        // The union holds a Guid: name it id.
        Guid id => Results.Created($"/bookings/{id}", id),

        // The union holds an Error with this code.
        Error { Code: ErrorCodes.ApartmentNotFound } error => Results.NotFound(error),
        Error { Code: ErrorCodes.Overlap } error => Results.Conflict(error),

        // The union holds any other Error.
        Error error => Results.Problem(error.Description)
    };
});

Error { Code: ErrorCodes.Overlap } is a property pattern. It matches an Error whose Code equals that constant. A pattern can only compare against a compile-time constant, which is one more reason to keep the codes in const fields.

There's no IsSuccess check, and no Value property that throws when you read it on a failure.

Don't return the union itself from the endpoint. ASP.NET Core 11 serializes the case it holds and returns 200 OK, even for an Error.

The Decorator Still Works

In my CQRS setup without MediatR, every command handler implements one interface:

public interface IHandler<TCommand, TResponse>
{
    Task<TResponse> Handle(TCommand command);
}

A validation decorator implements the same interface and wraps another handler. It checks the command first and calls the inner handler only when the command is valid. The validate function returns an Error for an invalid command and null for a valid one. One decorator covers every handler that returns a Result<T>:

public sealed class ValidationDecorator<TCommand, T>(
    IHandler<TCommand, Result<T>> inner,
    Func<TCommand, Error?> validate) : IHandler<TCommand, Result<T>>
{
    public async Task<Result<T>> Handle(TCommand command)
    {
        Error? error = validate(command);

        if (error is not null)
        {
            return error; // Error converts to Result<T> for any T.
        }

        return await inner.Handle(command);
    }
}

The decorator doesn't know what T is, and it doesn't need to. An Error converts to Result<Guid>, Result<Order>, or any other Result<T>.

A union stores its case in an object, so the Guid in Result<Guid> gets boxed. It still beat the Result class in my union vs Result benchmarks.

Add a Failure Case

Now each apartment gets a minimum stay, and a shorter booking has to fail.

The new error needs the minimum in its description. A static field can't take a parameter, so StayTooShort is a method that builds a new Error each time:

public static class ErrorCodes
{
    // ApartmentNotFound and Overlap as before
    public const string StayTooShort = "Bookings.StayTooShort";
}

public static class BookingErrors
{
    // Overlap as before

    public static Error StayTooShort(int minimumNights) => new(
        ErrorCodes.StayTooShort,
        $"The stay is shorter than the minimum of {minimumNights} nights");
}

BookingErrors.StayTooShort(2) returns an Error with the code Bookings.StayTooShort and the description "The stay is shorter than the minimum of 2 nights".

The handler counts the nights and passes the apartment's minimum to that method:

// DayNumber counts days since January 1, 0001, so the difference is the number of nights.
if (command.End.DayNumber - command.Start.DayNumber < apartment.MinimumNights)
{
    return BookingErrors.StayTooShort(apartment.MinimumNights);
}

I added the check to the handler and left the endpoint alone. The build passes with 0 warnings, and the one-night booking returns a 500.

The compiler does check this switch. If you delete the last Error error arm, the build reports CS8509, because an Error with any other code wouldn't match anything. But the compiler can't know which codes exist, because a code is just a string. So it makes you keep a catch-all arm, and that arm is where Bookings.StayTooShort lands. It's the same _ arm from the Result version, with a different syntax.

Give Each Failure a Type

The compiler can catch a missing failure only if each failure is its own type. So I turned each failure into a record. A record can carry the data the caller needs, like the apartment id or the dates, instead of a description string. Then I listed the records in a union of their own:

public sealed record ApartmentNotFound(Guid ApartmentId);
public sealed record Overlap(DateOnly Start, DateOnly End);

// Every way this use case can fail, and nothing else.
public union ReserveBookingError(ApartmentNotFound, Overlap);

I could put the success case in the same union and return that from the handler. But then every handler returns its own union, and the decorator only sees a type parameter, its TResponse. There's no conversion from a failure record to TResponse, so return failure; fails with error CS0029.

The fix is the same trick as Result<T>: a generic union the decorator can build for any handler. This one has three case types:

public sealed record BookingReserved(Guid BookingId);

// The failure the validation decorator returns, shared by every handler.
public sealed record ValidationFailed(string Message);

// T: the success. TError: the use case's own failures.
public union Outcome<T, TError>(T, TError, ValidationFailed);

The handler returns Outcome<BookingReserved, ReserveBookingError>. A BookingReserved converts to it directly. A failure needs a cast:

if (await store.IsOverlappingAsync(apartment, command.Start, command.End))
{
    // The cast makes it a ReserveBookingError, which converts to the Outcome.
    return (ReserveBookingError)new Overlap(command.Start, command.End);
}

Overlap converts to ReserveBookingError, and ReserveBookingError converts to the Outcome. C# doesn't chain two conversions like these on its own, so without the cast the build fails with CS0029.

The decorator is the one from before, with ValidationFailed in place of Error. It implements IHandler<TCommand, Outcome<T, TError>>, and return failure; compiles because a ValidationFailed converts to any Outcome<T, TError>.

The endpoint needs a switch inside a switch:

app.MapPost("/bookings", async (ReserveBooking command, ReserveBookingHandler handler) =>
{
    Outcome<BookingReserved, ReserveBookingError> outcome = await handler.Handle(command);

    return outcome switch
    {
        BookingReserved reserved => Results.Created($"/bookings/{reserved.BookingId}", reserved.BookingId),

        // The use case's failures: one arm per record.
        ReserveBookingError error => error switch
        {
            ApartmentNotFound notFound => Results.NotFound(notFound),
            Overlap overlap => Results.Conflict(overlap)
        },

        ValidationFailed failed => Results.BadRequest(failed)
    };
});

The outer switch handles the three case types of the Outcome. The inner one handles the records inside ReserveBookingError. A pattern on the outer switch can't reach into the inner union (that's error CS8121), so you need both.

Neither switch has a _ arm, and that's what lets the compiler help.

Add the Failure Again

Back to the minimum stay. This time, StayTooShort is a record in the error union:

public sealed record StayTooShort(int MinimumNights);

public union ReserveBookingError(ApartmentNotFound, Overlap, StayTooShort);

The handler returns it with the same cast:

if (command.End.DayNumber - command.Start.DayNumber < apartment.MinimumNights)
{
    return (ReserveBookingError)new StayTooShort(apartment.MinimumNights);
}

I left the endpoint alone again. This time, the build points at the inner switch:

GenericUnions\Endpoints.cs(39,52): warning CS8509: The switch expression does
not handle all possible values of its input type (it is not exhaustive). For
example, the pattern 'Bookings.Unions.StayTooShort' is not covered.

The compiler knows every case type of ReserveBookingError, so it can name the one the switch misses.

Make the Warning an Error

CS8509 is a warning, so the build still passes. If a one-night booking reaches the endpoint, the switch throws a SwitchExpressionException, which is also a 500.

You can turn the warning into an error in the project file:

<PropertyGroup>
  <WarningsAsErrors>CS8509</WarningsAsErrors>
</PropertyGroup>

If your project already has a WarningsAsErrors list, add CS8509 to it. Now the project doesn't build until the endpoint handles StayTooShort.

Here's the one-night booking with a two-night minimum in each setup:

The Result endpoint builds with 0 warnings and returns a 500 from its catch-all arm. The Outcome endpoint builds with warning CS8509 and returns a 500 from a SwitchExpressionException. With CS8509 as an error, the build fails.

The check only covers switch expressions without a _ arm. I also tried a switch statement and an if (result is ...) chain. Both skipped StayTooShort with 0 warnings.

Summary

A generic union Result<T>(T, Error) replaces the Result class with very few changes. The handler returns the value or the Error directly, and a generic decorator keeps working. It doesn't catch a new error code, though, because every failure is still an Error.

Giving each failure a type does. With the failures in their own union, wrapped in an Outcome<T, TError>, the compiler names the case an endpoint forgot. That costs a switch inside a switch and a cast for each failure in the handler.

To try it, swap your Result class for the generic union first. Then move one use case at a time to an Outcome when you want the compiler to check its failures.

The complete sample has every version of the use case, their endpoints, and my build and run output for each step.

Pragmatic Clean Architecture builds the Result class and domain errors into a complete booking application.

Thanks for reading.

And stay awesome!




Read the whole story
alvinashcraft
21 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Agentic Coding vs. Buying Components: The Long-Term Cost of Document Processing

1 Share
Agentic coding speeds up UI development and simple PDF exports. Complex document workflows add compatibility, testing, and maintenance costs. Compare building with AI and buying TX Text Control, and see why using AI with a document component can reduce long-term ownership costs.

Read the whole story
alvinashcraft
21 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

What Maintaining SwiftTerm Taught Me About AI Contributions

1 Share

If you maintain an open-source project right now, your pull request queue probably looks very different than it did two years ago.

I maintain SwiftTerm, an open-source terminal emulator library that is now seven years old. Today, I estimate that about 80% of the pull requests I receive involve AI in some capacity. Looking back, though, this didn't happen all at once—it came in distinct waves.

Disclosure: as a Mexican national that routinely writes tedious and typo-ridden English blog posts, I had Antigravity fix my writing and repeated tedious and repetitive points (as my wife often points out).

Wave One: Vibe-Coded Band-Aids and Fork Experiments

Before people even started opening AI-assisted pull requests on my repository, I would browse the GitHub network graph just to see what forks were popping up and what problems users were struggling with. Early on, what I found was a lot of "vibe coding"—folks patching around issues in ways that were fundamentally wrong, slapping surface-level band-aids over deeper terminal state bugs. I would fix or implement the feature, despite the fact that the user had not submitted the fix - for the sake of helping all my users.

In one fork I stumbled across, someone had clearly unleashed an autonomous agent to try to fix all of my open issues in rapid fire. Luckily, they never actually submitted those PRs—they were likely just experimenting—and it was only my nosy self browsing the network graph that spotted it. Still, looking through those commits confirmed the early reality: the fixes weren't worth merging. They solved surface symptoms without understanding the system.

The Rise of the Promptsplainer

Alongside those early waves came a new open-source archetype—one that many communities had to deal with: the Promptsplainer.

Some folks are really eager to particiapte in improving a project and LLMs have opened new doors, but they lack some basic etiquette.

A Promptsplainer is someone who asks an LLM a question, gets back a confident-sounding explanation or a sprawling patch, and suddenly believes they can override decades of hard-won domain expertise. They don't actually understand the underlying quirks, race conditions, or protocol edge cases of the codebase they are touching. When a veteran maintainer points out a flaw, the Promptsplainer doesn't go investigate the code; they just copy-paste the maintainer's review comments straight back into their chat session and paste whatever the bot spits out next.

You don't need a massive daily flood of Promptsplainers to feel the damage. Even the occasional encounter can fill a maintainer with rage - and with good reason.

Wave Two: "Send a Patch" Finally Became Real

Here is what has changed dramatically over the last year. We went from AI fixes being flat-out wrong or lazy band-aids to pretty much landing in the right ballpark.

To appreciate why this matters so much to me, you have to remember what maintaining an open-source library looked like just a few years ago. Back then, I would get a steady stream of bug reports—and if I had the spare time, the patience, the kids went to sleep early, and my Netflix queue was empty, I might actually sit down and fix the bug.

For decades, open-source communities had a semi-joking, semi-exasperated stock response whenever a user asked, "Why doesn't it...?". We told them, "Patches welcome," or "Send a PR." Most of the time, we knew they wouldn't, because diving into a complex codebase from scratch was too steep a climb. The perfect storm between unpaid volunteer work, uneducated takes and exasperation.

Like many others, I have witnessed the change from getting bug reports to getting detailed pull requests. And I am personally grateful for this.

My philosophy on incoming contributions comes down to a simple reality: every PR represents a real pain point caught in the wild. It means a real user ran into a problem in their day-to-day work, reported or tracked down the issue, found a working solution, and felt the pain acutely enough that they took the time to package it up and upstream it.

As a maintainer, that is an infinitely better signal than my own laundry list of wish-list items sitting in the issue tracker. Even if the implementation needs additional work, someone just handed me proof of a real-world problem along with a concrete starting point to fix it.

Multi-Agent Code Review on My Side of the Table

The catch is that many coding models and agents still have a bad habit of just doing the fix—taking the shortest path to make a test pass without stepping back to look at the whole library. And not every contributor has learned how to tune their agents for deep engineering review, or has access to the best models for it.

The first pass of AI-generated code often needs work, and that is okay. Just as we spent years developing the discipline to master our programming languages, debuggers, and in some cases, write m4 macros, we now need to develop the muscle for using AI tools effectively—learning how to steer them, verify their assumptions, and audit their output.

For me, building that muscle meant putting AI on my side of the table to bridge the gap. Before I even bother reading a contributor's patch line-by-line, I religiously run /code-review in Claude and /review in ChatGPT [1].

These review passes routinely catch far more than narrow syntax nits—they surface genuine architectural flaws, subtle API breakage, rare side effects, and terminal conformance problems that would take me hours to trace manually [2].

Armed with that feedback, I can point contributors toward concrete architectural fixes—or, if someone disappears after opening a PR for a critical bug, I can clean up their branch and land it myself.

Some maintainers lament that reviewing these PRs feels like talking to someone who just copies and pastes feedback into a remote LLM. But we are still communicating with a human being on the other end. That gives us a real opportunity not just to coach contributors on how to use these tools responsibly, but to model and adopt better engineering practices across our industry. Given that the economics of top-tier reasoning models aren't ideal for everyone doing casual open-source work, I’m happy to foot that bill on my end for the sake of keeping my library healthy.

The Friction of One-Size-Fits-All Rules

This brings me to why I’ve been watching the broader debate around AI policies in large projects like Gnome and Godot with a lot of sympathy—and a bit of concern.

At Godot's massive scale, protecting volunteer reviewers from unvetted submissions and the occasional Promptsplainer is a completely understandable instinct. Nobody wants their Netflix time eaten up by drive-by code the author didn't bother to understand.

The challenge is that drawing hard lines around how code was written inevitably creates friction for experienced contributors who are already doing the architectural heavy lifting. Recently, I tried to upstream a small, production-tested bug fix to Godot as a trial balloon—one of roughly 60 to 80 improvements my team has built and tested in our own tree. Because I disclosed my AI workflow honestly, it ran afoul of their strict guidelines and was rejected.

When a policy polices provenance rather than quality, two unintended things happen:

  1. It penalizes transparency: Honest contributors who disclose their tools get blocked, while others are quietly nudged to keep quiet and pretend they typed every character by hand.
  2. Good fixes stay locked in private forks: Rather than wrestling with policy friction, teams like mine simply keep useful patches in our own internal trees. Because AI has made maintaining forks trivial, it doesn't slow us down—it just means the broader community misses out on fixes that could have helped everyone.

Accountability Over Provenance

The Promptsplainer is a real headache, and open-source projects are right to push back against uncomprehending, drive-by contributions.

But the antidote isn't banning the tools—it's requiring human accountability paired with better review tooling on the maintainer's side. At the end of the day, as the maintainer of a library, it is my role to make the editorial decisions about what goes in—and the people who depend on my library trust me to make those calls. Whether a patch started in an LLM prompt or was typed out by hand doesn't change that responsibility. If a contributor understands the problem, has tested the fix, and can engage thoughtfully in review as a human being, the models they used in their editor shouldn't disqualify their work.

Of course, scaling that kind of review culture when a handful of core maintainers are already stretched thin is a structural challenge all its own.

[1] With Claude I use Opus 5.5 alongside /review in GPT 6.2 with Sol-xhigh. In Claude, /code-review actually launches multiple distinct agents in parallel, each focused on different goals and common engineering mistakes. Looking forward to Antigravity to get this.

[2] In fact these reviews are so thorough, that I use /code-review on my own changes before shipping. In a seven-year-old codebase, it is impossible to keep every historical invariant in your head at once, and those agents regularly catch edge-case scenarios I had completely forgotten about.

Read the whole story
alvinashcraft
22 minutes ago
reply
Pennsylvania, USA
Share this story
Delete
Next Page of Stories