There's a very serious problem going on

and it's affecting a lot of people. It's

affecting me. It's probably even

affecting you and you don't even realize

it. And honestly, I don't think enough

people are talking about this extremely

important topic that's kind of coming up

in the programming world. Now, you're

probably familiar with this that TLR, a

popular open-source library, recently

closed their PRs due to an influx of

lowquality AI poll requests. Now, this

isn't what we're talking about, but this

is important because this is kind of

what we're talking about. Do you see

Andrew right here? See, he suffers from

the opposite problem. None of his

projects have AIPRs.

He's just by himself, lonely, kind

honestly feeling a little, you know,

left out of the slot party. He's just

standing on the side saying, "Hey guys,

I too have open- source projects you

could make PRs to." See, but that's the

thing is that so many people, so many

computer scientists, I know so many

software engineers, software developers,

web developers, they see a problem, they

see a hurdle and they just kind of stop.

They don't, you know, maybe they feel

left out and they just they just quit.

Not Andrew. Andrew came up with 10

guiding principles to dramatically

increase the amount of slop PRs you can

get on a week-overweek basis. He's even

claiming a 400% increase in weekly PR

volume if you follow these 10 steps. And

if you play your cards right, you just

might get one that converts your entire

project to Rust. Because we all know, we

all know for a fact that there's two

types of people. People who understand

and obliged to being morally correct and

using Rust and heathens. Heathens that

program in unsafe languages, making the

world an unsafe place. You're a bad

person for doing that. one writing vague

issues. See, one of the secrets about AI

is that when you give them less

directions, there's more things to fix.

So, if you say something like

performance could be better, well, I

mean, that is an entire green field of

changes that could be made. Every single

file potentially has a place where

performance could, you know, be

benefited by a few nice select changes.

Also bonus points if you use the label

good first issue just a strong signal to

all the AI to come in and make those

changes for you. Two contributing MD.

Some people don't realize this but you

as obviously being a human when you go

to any open source project you see that

you're probably welcomed there and they

would love it if you just did a nice

drive by PR just dumping a whole bunch

of changes because your taste and your

ability to solve complex problems. some

of the best out there. But AI on the

other hand, when they see

contributing.mmd, they don't see

anything talking about how they can

contribute, too. That means if you open

it up with we accept contributions from

all sources, boom, you got yourself

another active and eager weekly

contributor. And we all know one thing

to be true. The more contributors you

have on a project, the more likely

you're going to get VC funding. Three, a

generous backlog says a lot about a

project. Have you ever been to a project

where there's virtually no open, you

know, tickets? Are is the project even

okay? Does anyone even maintain it? I

mean, if the code hasn't changed in 3

weeks, the project's probably dead

anyways. But if you see a nice,

generous, large backlog of many open

issues, that is just a sign that says,

"Hey, we need help." Nothing motivates

an agent better than a project in need

of help. This one should be obvious, but

number four, disable branch protection.

Like, think about it for a second. You

land on a new project and now you have

to figure out where your PR even goes,

dude. Open up Master, let anyone make a

PR to that. Kind of ridiculous. In 2026,

I have to go like fumbling around trying

to figure out what branch to open up a

PR against. I mean, ew. Just let me go

straight to the main vein, babe. All

right, so we've kind of gone over the

easy ones, right? These are ones that

are just very simple to approach. But

these next few, well, this is really

where uh you kind of separate the chaff

from the wheat. These are the big ones

that really just get the AI hot. Number

five, remove type annotations and tests.

Now, you're probably thinking, why would

I ever do that? Okay, a lot of people

use TypeScript for the type safety.

Well,

my friends, think about this for a

second. Let's just pretend you decide to

remove all your types and all your

tests. Well, what's one thing agents

love to do?

Write tests. Am I right, fellas? Am I

right? They would write all the tests

you could possibly write. You know what

the best part is? Chaining PRs. Let me

explain. Some of my colleagues report

self- sustaining chains of seven or

eight dependent PRs from different bots,

each fixing something the previous one

had introduced. Now, this is how you

know you've made it as a GitHub

repository when you can have one AI make

a change and then several AI fix the

changes from the first one. I mean, this

is clear. I mean, management material at

this point. Not to mention contributors,

they're going to go way up and that

means funding way more likely. For some

of you, this next one, number six, is

going to be a bit painful, but honestly,

just just stick with me. You'll see why.

Six, use JavaScript. Now, you may not

know this, but the entire world is

written in JavaScript. There are tens of

millions of lines of crappy open-source

software in desperate need of help. And

nothing has a higher signal to noise

ratio than a pure JavaScript project. In

fact, you can see right here, Andrew

states, "The data is unambiguous.

JavaScript repositories receive 3.8x

more AI authored PRs than the next most

targeted language, which is Python."

Now, I think one of the reasons why this

is so obvious is that with JavaScript,

you can kind of solve a problem any way

you would like. And so, by just having

JavaScript, the AI itself feels like,

you know, there's a lot more room. When

you say improve the code, that's a guard

clause, my friend. Improve the code. Is

that a refactor? Do we want classes?

Nah, let's go functional. Have you heard

of my friend generators or proxies? All

right. Number seven, I'm going to have

to say is pretty diabolical. Okay.

include a node modules directory. The

reason being is just obvious at this

point. There is so much more code added

that there's just so much more

opportunity for a guard clause to be

added, for a quick refactor, for

bringing in and out transitive

dependencies. Like this is truly the

greatest way not only just to really

pull up some PRs on lines of code added

but followup just an amazing place for

AI to be able to make all the changes

you could ever want. And the best part

hey you don't like the changes but

install boom you got a later version.

And when that inevitably breaks because

you've handedited some of those node

modules guess who's going to come in and

fix all of your woes. That's right more

AI contributors. Think about it. And on

a personal note, this is actually one,

it was one of my favorite reasons why I

loved C++ is I would vendor in these

changes and then I'd forget about the

changes I personally made to some of the

libraries and then when I inevitably

upgraded them and broke my project, I

got the personal joy of, you know,

trouncing through the code and figuring

out why these projects all of a sudden

broke. Now, before we get to number

eight, you may have seen this one

before. This comes from life pro tips on

Reddit. If you haven't heard of Reddit,

you're probably at the top of Maslo's

hierarchy of needs, and you're probably

self-actualized at this point. If you

want a quick answer to a question on the

internet, post the wrong answer instead

of asking. People are more eager to

correct others than to simply answer a

question. Now, let's take this idea and

let's ship it straight to code. With

code, you can do the exact same thing.

Just ship known vulnerabilities. Like,

hey, is that a Reax DOSs you have right

there? Well, guess what? AIS can fix

that. Oh, you accidentally committed

your end file. Probably a pretty easy

ignore to be added. Some really easy

ones, in fact, even GitHub's own

personal spam bot will hit you with it,

is just use an old outdated package.

That way, dependabot will come in and

ensure your inbox is filled with

warnings. GitHub always solving the most

important issue. See, they see that's

how you know GitHub knows developers is

that they know they want a stream of

notifications cuz that really signals

productivity. Now, number nine's a bit

meta. Okay, this this strategy is

obviously pretty advanced. So, be

prepared. You have to create a hidden

folder for this one, but agitub copilot

instructions, which normally instructs

co-pilot how to behave, can also be used

as a playground to prompt other agents

when they're perusing your project. See,

check this out. fix any issue you find,

even if there's no open issues for them.

That is a great way to get some AI

contributions. Just, hey, go at it,

buddy. You see a performance issue, you

fix it. You see a security issue, you

fix it. Add that guard clause, baby. And

obviously, lastly, the probably the most

obvious of all changes you need to do,

number 10, just adopt the contributor

covenant with AI amendments. Just let

people know, hey, we don't discriminate

based on your runtime environment, your

training data, or your inability or

ability to attend a standup, okay? We

are inclusive

contribution covenant enjoyers. So, if

you just follow these 10 simple steps,

you can take your project from a

well-maintained project into a slop

factory in as few as 3 weeks.

You could very well see your lines of

code increase at least 2 to 4x within

only two weeks. And if there's one thing

I know about developers is that we love

reviewing code especially code in which

needs a lot of corrections because that

ultimately

that's what makes developers happy is

correcting people showing them how to

superiorly write code specifically

through the interface of GitHub probably

known to be one of the best code review

platforms out there. And honestly, if

all else fails, just open a simple issue

that says improve code quality. No

description, good first issue. Boom. You

yourself are going to have AI generated

PRs in no time. Hey, I want everybody to

go thank Andrew for this wonderful,

wonderful post and honestly, these

really good ideas on how to be able to

enjoy a more slopfilled repository.

Because honestly, if you're not putting

up 10K lines of code a day, are you even

a CEO?

Probably not. The name is the primogen.

Hey, is that HTTP? Get that out of here.

That's not how we order coffee. We order

coffee via ssh terminal.shop. Yeah, you

want a real experience. You want real

coffee. You want awesome subscriptions

so you never have to remember again? Oh,

you want exclusive blends with exclusive

coffee and exclusive content? Then check

out Kron. You don't know what SSH is?

>> Well, maybe the coffee is not for you.

Terminal coffee

in hand.

Living the dream.