Ask HN: How to say no to a GitHub issue feature request?

A lot of people are suggesting being cordial. For example, "thank you for the request but we cannot handle it at this time". This works for the usual people asking for feature requests but your problem is not so simple.

If you have a persistent requester you can still be professional but far more firm. I would personally say something along the lines of "I have noticed you making a lot of requests. I do not have time to handle them all, but I would be happy to discuss a support contract with you or your company billed at my hourly rate if you need additional support".

Usually demanding money and then ignoring them is enough to either convert them into a customer or get them to buzz off to someone easier to pick on. Since this isn't your case - they won't pay at all - you can be more firm. I don't use github but if it's possible just flat out block them. You could additionally just reaffirm that given the frequency of their requests you would normally service this with some kind of contract and then ignore them.

The key take away is never give someone who exploits you the chance to take advantage of your kindness. It's at these points you need to be firm. Otherwise they will continue to harass you.

The best thing to do is to decide where your boundaries are, and then tell them.

I was in your position many times. I was so frustrated to feel like the other person was entitled to my time. Then I had to fight my urges to tell them to fuck off, wasting even more time and energy in the process. Even if I replied, it wasn't helpful to anybody if I was being polite but passive-aggressive.

Then I realized that it was a huge misunderstanding. How can people know what my limits are if I don't tell them? We don't all share the same sensibilities and background. Instead of getting upset, it's possible to tell people and move on. 99% of the time people understand and respect that.

Since then, I adopt the following classification:

1. Is the feature interesting to me? Let them know

2. If not, would I accept a PR for it? Let them know, with also some criteria for inclusion. No half-baked attempts please.

That's it.

One surprising thing I discovered is that I wasn't entirely clear where my limits were. Going through that process over and over again helped me figure that out. And become better at communicating clearly.

This is great communication advice. Your original state sounds a lot like the "asker" vs. "guesser" cultural problem [1]. I've found putting a label on those two outlooks to be very helpful.

1: https://www.theatlantic.com/national/archive/2010/05/askers-...

If you would like to see an example of a polite and meaningful discussion I had with a maintainer declining my feature request, you could read this:

https://github.com/nblumhardt/serilog-timings/issues/52

But I would not expect every requester to be polite and accept a NO...

That really is a great example, but it's very noticeable that you both went into it with the perfect attitude (and maintained an awareness that each had different needs & goals).

It's the "Veruca Salt" case that's much more difficult to solve for.

Absolutely...

I tend to first be polite, and then after some conversation do just nothing in this case... don't feed the troll

Thanks. Hehe, yes indeed. But you can't always get what you want...

And if 2. is "no" then let them know why not, but there is no need to "debate" it further either.

Sometimes it's very important NOT to add features to a project. In fact I would argue that this is one of the strengths of OSS projects compared to "enterprise software".

Exactly.

Each software has a shape that makes sense, in the eye of the creator. That shape might change but it has to stay internally consistent somehow.

Unlike companies, we don't have to eternally grow the software to satisfy every customer and stay releavant. Projects come and go and this is a good thing.

Sometimes projects "go" earlier precisely because they keep adding shit. Others are eternal because they keep a very narrow scope with high quality.

explaining "why" is good, but remember that "i don't want to" is a valid reason why. the reason doesn't have to be a technical one.

Along with the 'no' it may help to point out that they are free to fork the project and add the feature to their own fork, or hire someone to build it for them. That won't stop the most extreme class of complainers, but it'll shave of another few.

Why pointing out something that is a distinguishing feature of open source?

I don’t need your permission to fork off the license allow me to, but telling me that I’d like putting a comment like „btw, did you know that 2+2=4“.

Sometimes people get upset about their project being forked. Explicitly offering it as an option assuages any concerns the requester may have about that.

This whole question in the first place is about people that showed that they don't know such things and so need to be told such things, by the nature of their demands.

> Why pointing out something that is a distinguishing feature of open source?

Because users exist who are:

- clever enough to use github and open an issue

- not clever enough to know this is a possibility

- care about their problem enough to complain, but not enough to do something about it

By basically telling users "if you really care, you could do $labori tensivething" often they realize that they do in fact not care enough. And if they do, you could still use the fruit of their labour if it really turns out good.

You are a more advanced user. It’s obvious a lot of the users like the one in the OPs example are not. They don’t know the nuances of how things work. They may think things like people are being properly compensated in some way for open source code projects. They may not know about forking or it’s possible to hire someone to add the feature you need. Bounties etc.

Excellent advice. This is like the golden rule of dealing with people. Well, the other golden rule. The professional one, I guess you could call it. Be explicit, polite but firm.

It works well for both managing people or doing customer support. It doesn't work for everyone. But as you note, it works in the vast majority of cases.

If you've read the Ask a Manager column, you'll recognize it as a core principle there. And if you've ever watched The Dog Whisperer, you quickly discover it works for dogs, too. (You just have to learn a few tricks for communicating with them.)

I think this is a good advice.

To add on, for some of my projects I explicitly list out-of-scope areas in the README to give users a better idea on where the project boundaries lies.

This is especially true because the closer you are to limits, the more a reasonable and politely written request can look like a demanding screed from an asshole. It's safer to assume good intentions than risk blowing up on some innocent person.

"This feature is a bit out of scope"(if applicable). "Our team, aka me, has limited time for this project, and I just don't have the bandwidth. I can answer questions or possibly collaborate if you'd like to have a go at the code yourself though."

"This is a personal/internal use project made available to the community as is, and adding features outside of what I need for my own company is not a priority. You're welcome to submit a PR if you do get the feature implemented yourself though."

(If applicable) "It does seem useful so I'll leave this issue open in case someone else wants to implement it, but I don't currently have a need for it".

"If this feature is very critical, we can talk about some paid support options, but otherwise, free software is largely created by companies and individuals for their own needs, and we don't have time for every feature request"

There's another consequence to consider as well: even if a PR does materialize externally, do you want to sign up to maintain it in your codebase?

Exactly. Pull requests are not a golden ticket here - they still take (a lot of) time to review and maintain.

In my experience pull requests, particularly for (larger) features, can be net negative contributions. If the pull request is done poorly they can easily take more time to review, fix and maintain than it would have taken the maintainer to implement the feature in the first place.

If not, the maintainer could say "feel free to fork it".

> (If applicable) "It does seem useful so I'll leave this issue open in case someone else wants to implement it, but I don't currently have a need for it".

Accompanied by something like a "WONTFIXMYSELF" tag?

One way to think about it:

By making a FR, the user is providing free feedback. This feedback might be useful or not. Still, remember that the user has invested his/hers time to submit the explanation. Be nice if possible. Passionate users can be a bit extreme, so give them some slack. But if the user is not behaving politely, ignore him.

The user has NO idea how expensive would it be to implement this FR. Even developers often have no idea, so don't feel offended, if he/she doesn't know. Communicate it to them so they can manage their expectations.

Don't say you'll do it for X amount of money. The amount will either be too high (unless it's a corporate user) or it'll be too low and you'll be devaluing your work. If you would do it for a fee, tell them they'll probably need to raise some funding for you to implement this feature or hope someone else is prepared to do it for free.

If the feature doesn't fit your vision for this software, thank them for the input and clarify to them that at this time this FR doesn't fit your project. So, they'll need to find an alternative solution for their needs.

it would be interesting if github allowed the user to submit the feature request and commit x amount of dollars they are willing to pay to have it implemented. if the maintainer wants to entertain the offer, the two agree, and requestor submits the money to github to hold in escrow until the feature is implemented or the time has expired.

This exists as third party services. IIRC it’s exactly how bountysource used to work.

I think the model never took off enough to be attractive to github to implement on their end. But yea I think it would be cool and more popular if integrated directly in it.

Users don't understand costs, especially for certain countries. The biggest bounty I got was like $300 for a solid week of work. Most were a few bucks. It was a waste of everyone's time and money, except BountySource.

But really, people should not put you in this situation and discuss the work they are about to do. After all, we don't do major "surprise" work in the workplace (usually).

Hi, sorry but this is simply not something I'm interested in implementing.

Further, please remember that GitHub maintainers do this for free, on their own time.

Thanks!

Anything more than that, block and move on. I've been on GH for 10 years or so and it's gotten really bad in the last few regarding pushy dickheads like this.

You owe nothing to them, and if they can't behave within the OSS ecosystem then they're going to get blocked. Plain and simple.

In the past, I've simply responded to drive-by PRs with "No thank you :)" and closed them. Not common but sometimes people do stuff that makes no sense and you just can't really say anything other than that.

As someone who makes lots of merge requests, please don’t add the further statement. In my experience while it’s well intentioned, it (understandably) frustrates contributors because it’s making an assumption that they aren’t valuing your time, which you don’t know.

Just my 2¢, at the end of the day do what feels best for you, but you may drive away some contributors.

I think that statement should only come after something that justifies it.

The statement implies that the requester is acting in bad faith. If they are, fine, but if they aren't it's somewhat bad faith to treat them as if they are, and in my experience it can really change the tone of a community when all initial interactions start out assuming bad faith.

As someone who has to deal with a lot of PRs, yes I'm going to tell you this if you're being pushy. Of course I won't say this if you're polite like most people are.

In OP's case, it sounds like the issue submitter is already being pushy and demanding.

Exactly, that's what I meant. Of course don't just blindly say this to someone who hasn't been rude or pushy.

My decision tree:

1. Do I think this is a good feature? No -> I'm sorry, I don't think this is a good fit for the project.

2. Am I excited about implementing it? No -> This is a good idea, but I'm not up for adding it right now. If you or someone else wanted to send a PR I'd be happy to review!

3. Am I going to get to this soon? No -> This is a good idea, and something I'd like to add, but I might not get to it for a while. If you or someone else wanted to send a PR I'd be happy to review!

4. If it passes all these filters it's generally something I do right away. Fewer and fewer of these as the simple excellent features have generally all been added.

So far I've found that as long as I'm clear with people no one gets obnoxious. If they did I'd say something about how this is a project I maintain for fun in my spare time.

Hey, this is a situation I'm quite familiar with, both as the PR receiver, and observing PR interactions on other popular github repositories.

How you deal with it is very much down to how you want to engage, and your energy levels too. It can be anxiety inducing too because many of us want to avoid confrontation, and saying 'no' can be confrontational, but you need to remember that the other person is not in the same mindset as you.

Options.

You are perfectly entitled to completely ignore the request. Don't comment any more, just stay silent for ages and ages. The issue can languish for years. If you want you can close it off after a long time. Even then you can close it without comment, or say you don't plan on implementing anything here. You may not like this option as it feels like you're running away, but I'll also say that it's something that happens across many repos for many years, both intentionally and unintentionally.

You can nip the issue (haha... get it?) in the bud. Be straightforward and say that you are not planning on implementing, maintaining and supporting that feature. Your time and energy are limited, and you don't feel it's a feature that you want added to your codebase. Close the issue with the comment. The reaction may be varied but it is important that you stick to this statement and not entertain further commenting, because each new line can sometimes be an 'in' to argue more.

You can take the most pacifist route which is to keep explaining, and refuting, that you don't want to implement the feature. Most people are quite receptive to it and will actually understand, but it's also possible you've encountered someone who is not able to understand your intention. This can be mentally draining as you're speaking to someone of a different mindset, who views you in a certain way, and nothing can convince you otherwise.

But at no point is there any need to insult anyone. Keep in mind it's your codebase, and you will be maintaining the feature going forward. If you do not respect your time, nobody will. Please respect your time OP.

It sounds like OP has a feature requester who is taking advantage of their passive nature. As you stated people want to avoid conflict, and based on what OP wrote it's obvious this person is taking advantage of that.

The only options here are to either ignore them or confront them directly. It helps that asking them for money for all this support they want, and then them refusing, vindicates you and allows you to just flat out ignore them.

Kindness first, always. Maintaining an OSS project will push your personal growth to a new limit.

- be direct: I do not wish to have that feature in the project.

- explain: the vision of the project is xyz. This feature you’re requesting does not fit in the vision because abc. I don’t think it belongs here as it will become a maint burden and a distraction from the goal.

- encouragement: if you do think you’d find value, i would encourage you to fork the code. I’d be willing to give you a few pointers on how to implement, but that’s the extent I’m willing to provide help for free.

- disengage: do not argue. Do not create personal attacks, and ignore any thrown your way. If they persist, link back to the original explanation so everything is in one place.

- be willing to be wrong. Sometimes people’s rudeness makes us respond with obstinacy. If you can calm the situation to a civil discussion, do consider their viewpoint and alleged benefits.

I add that if the request is reasonable, I always ask back for something. Usually for a specific use case with code example, or maybe a prototype implementation.

I only ever actually react if the issuer demonstrates that it is important enough to them to put in some work.

Because 95% don't.

Once I posted a super long reply to a super long and messy feature request: https://github.com/database64128/youtube-dl-wpf/issues/131. It's basically like this:

> First of all, thank you for your support...$blah_blah_blah

> Unfortunately, I have to say no to some of your requests. $project is just a small side project of mine. My approach to its development will always be to prioritize my own use cases, while also catering to the community as much as I can. As you may have noticed, I have already implemented a bunch of new features and made quite a few changes based on community feedback. Decisions on whether to adopt a proposal from the community are made by evaluating the usefulness of the proposed feature or change for me and the wider community, and the feasibility of implementing it in my limited spare time.

> Now that I have explained my ways of doing side projects to you, let's go through your proposals:

This sounds like a problem you will face many times in the future and therefore you may benefit from finding a solution that will solve for both this request and all similar future requests. For example, instead of writing any customised response, you could write a blog post / make a webpage that explains your approach to these types of request and then simply link to it in a reply. Then every time this comes up you can simply paste in “Thank you for your request. Please see [URL]”.

I find doing this type of thing (creating nice canned responses, creating reusable answers) nearly always pays off in the medium and long term and find that it’s much easier to put the effort into a response knowing that you’ll get long lived value from it vs it just being useful for one person.

Similarly, I often find others have done similar and if their thoughts align with mine I don’t need to write the answer myself but instead can refer to someone else’s blog post etc.

> simply paste in “Thank you for your request. Please see [URL]”.

I think this can make people feel like you don't understand them and maybe make them angry. It feels like an automatic response you would post when you haven't even read the request. I think you should at least clearly say that you don't want the requested feature in the response, then you can link to the page.

That sounds like a them problem.

"Pull requests welcome" if you want the feature. "Fork off" if you don't.

> That sounds like a them problem.

Yes and it's not nice to give people problems. It can even come back to you if they don't feel like they got a clear response and continue to bother you.

I like to communicate in ways that are clear, honest and complete because that way people get the information they want and we can understand each other. I think the world would be a better place if everyone did that and therefore it's what I recommend people to do.

On the flip side, people need to be okay with "No."

Yes, a "no" is basically what I think was missing from that example response. Something clear that makes the requester feel like they got a response to their request.

You can just politely say no. That's it, don't feel obligated to do anything else (and for that matter, even this is optional).

I don't recommend you say f off or be hostile, it's not worth the trouble, be gracious and kind, but don't be afraid to be firm and establish your boundaries.

If he keeps bugging you, simply ignore him or block him if needed. There are lots of entitled people on the internet, it's up to you whether you ignore them, get upset or comply with their unreasonable demands.

Open source doesn't mean free work, it also doesn't mean you need to review other people's PRs, and it doesn't mean you need to merge someone's pull request with an amazing feature.

Everything is optional and at any time you can say no.

> You can just politely say no.

To emphasize even more, you do not need to explain yourself at all, in any way. You may want provide your reasons / rationale, but you don't have to (see other comments stating that as well).

Absolutely.

Another answer I don't recommend is "PR welcome". Accepting some random person's feature then getting it merged comes with lots of costs, from the one time cost of code reviews to the ongoing cost of maintaining the feature.

Only say "PR welcome" if it is really welcome.

> To emphasize even more, you do not need to explain yourself at all, in any way.

I would suggest that you should not explain yourself in any way. Chances are they would just view that as an open door to argue their point and they will try to use your words against you.

A polite no is still a no. Some people just need time to realize that.

I think you have those options on how to react to a feature request:

  1. Great idea, I/we will implement it  
  2. Great idea, Pull Request welcome!  
  3. Out of scope, won't be implemented (even if a pull-request is submitted), because ..., /close  
  4. Out of scope, (no explanation) /close

If you're the single maintainer of a project, it's easy. Write one sentence and just close the issue or pull request.

If you're a team maintaining a project, you need to agree with the team on that, obviously.

But keep in mind: random Github users are just random Giuthub users, random people. Treat them with the respect they deserve. If they don't deserve a lot, just close their issues.

I like this as a policy, might give a brief explanation why 4. You might link to a roadmap for example that makes it clear why the Issue isn’t being prioritized.

“ I currently don't do free support for this project. If you have a budget, then I can make time. Let me know.”

And then I closed the issue. I can’t see any problem with this.

Consider applying the exponential back-off technique. Originally designed for firewalls, it works well with annoying people! (particularly Slack etc. with faster rates than below.)

This only really applies when you owe people an answer, so I'm not even sure this applies here. You could simply palm them off politely.

Here is how it works.

Silly request 1: respond within the hour

silly request 2: respond within a few hours

silly request 3: respond the next day

silly request 4: respond within a week

Stand your ground. No one can make you lose your cool or upset you, unless you let them. Politely decline every time and they'll get the drift, slowly.

And if your product is open source, they can fork it and shovel it themselves.

You'll become "the guy who doesn't respond to GitHub issues" and that is going to backfire on you because commercial software, or other projects, or prosoective employers are going to be coming and saying "you see, this open-source software is not or poorly maintained"

I recommend on saying "Thanks for sharing the idea"

Once you have time to work on your project, then you create a new sprint based on a couple of ideas that you or users submitted.

The question of whether to implement the feature or not, is to be answered during product priotization while assessing potential engineering cost and impact of the feature.

Whether the user is annoying or not isn't directly relevant, and if it is, it should be based on potential reputational risk under the impact score.

> You'll become "the guy who doesn't respond to GitHub issues" and that is going to backfire on you because commercial software or other projects are going to be coming and saying "you see, this open-source software is not maintained"

I fail to see how it would be a bad thing.

You're mistaken this as my default response handling. That's incorrect. This is only for the repeated and unsolicited actors who have nothing better to do than make your life a living hell.

The logs will show that you're being responsive, and that this person clearly doesn't let go.

"Nice idea, you should get someone to implement this. Not me, I only maintain the software features as I need them."

Keep in mind that if the user doesn't speak English natively they may be coming across more aggressively than they actually mean to.

I tag all new issues that come as “Feature Request”, “Bug”, etc. and then as far as I’m concerned, unless I’m interested in the issue, my work is done.

Those then serve as an excellent roadmap for anyone who wants to contribute, but my projects are built for me and I work on the parts I want and need.

I also use GH automation to auto-close issues after a year. If no one cares enough to implement the change in a year, no one cares.

Your project is yours, feel free to ignore everyone else.

I also highly recommend watching this talk by Pieter Hintjens a couple of times. It is brilliant https://m.youtube.com/watch?v=uzxcILudFWM

(I’m the creator of WTFUtil).

"No" is a full sentence. You do not owe anyone an explanation beyond "I do not feel like working on this feature".

This can come off as rude if you’re trying to make a collaborative project. I’d link to a roadmap or be honest and say this doesn’t pique your interest.

You are right, but at the same time when I say no with a reason, people think that they can debate. No just means no.

You owe people politeness, but I don't think that you owe them a justification for not wanting to do things. If it's rude to say no, it's rude to ask.

If you don't see that the feature would fit your vision of the codebase then just tell them that.

If you think it is a useful feature tell him that you currently don't have time to implement it yourself but a PR is welcome.

Often people only want that there issue is tracked, so to avoid conflict and just do nothing just tell them that it goes into the backlog of future features to be considered ;)

Just another point to consider: sometimes reviewing a PR and getting it up to your standards is significantly more work than doing it yourself.

If you don't have time to implement it, there is a chance you don't have time to review it.

If it is like that, you can simply say you don't have the bandwidth to review, and/or you don't want the feature in your repo. You can emphasize that they can always simply fork the project and do whatever they want with it.

> The main reason is, the requester behaves like I am hired to customise the software for him. And I should keep working until he is satisfied.

Just tell him your fee and that you’ll start for a 50% deposit.

The truth is, you'll have this for any kind of software you're doing paid or otherwise. Learning how and when to say no is an important skill.

Usually I just tell people that something's out of scope, or that if it's in scope, it's something on our radar, but not at the top of our priority list right now. If it's the first time someone's made that request, I'll often note that.

If somebody gets pushy, just don't reply.

But there's also a decent usability rule: the first time users request something, they're stupid. The third time users suggest something, you're stupid. That's obviously not hard-and-fast, but it is important to keep in mind that even if you think the users are wrong on something, at a certain point, if there are lots of them, they may be right.

Whether or not you care depends on the type of OSS project.

If it's public facing I would suggest that you keep it in context and PR friendly and say something like:

"I am declining this as it is not fitting with the direction of the project and other users' requirements. You are free to fork it and maintain your own version"

> You are free to fork it and maintain your own version

I’d leave that out. That’s unnecessary as it’s an implied freedom of oss, and it can come off as aggressive / dismissive.

"Thank you kindly for your suggestion as to how the project can be advanced in a prosperous manner. At present, the project contributors do not possess the bandwidth and time required to implement this feature. Although it is not a present priority for us, we would welcome a patch implementing this feature."

Move off of GitHub. It's clear that neither the founders nor the new Microsoft management care about this kind of noxious spam. Or at least, they can't be bothered to give you the tools you need to deal with it (I want to be able to, at my discretion, (1) disable creation of issues and pull requests (2) force an approval process where I must approve issues and PRs before they even appear on the page (3) be able to decline PRs without the original poster or anyone else from getting an alert).

The fact that they won't add these features isn't surprising, GitHub is designed to be a corporate product, for corporate dev teams. That's who pays the bills, not open-source projects which are less obviously a benefit to GitHub (they are, they bring corporate users/payers to the platform).

It's clear you don't want to be confrontational in any way. I understand, it's also not in my nature. You shouldn't be forced to deal with this, yet on GitHub, you will be.

You can just block them from the repo. If it's using up your emotional energy after you've explained your position, be proactive and push it away. I realise that's the nuclear option, but at some point you have to draw a line - especially when it's your time and your mental health that is being drained away.

I've only needed to do it a couple of times on my projects, but sometimes it's needed.

Just reply something like "This feature does not interest me, but patches are welcome!" and leave it at that.

This does not mean you actually will merge any PR for said future, should they ever materialize.

> This does not mean you actually will merge any PR for said future, should they ever materialize.

If you don’t intend to merge the feature, you should not say that patches are welcome, that’s an asshole move.

If you’re not sure, say that and that they can open a pr but you can’t make any promise.

If you’re not interested in the feature and are not willing to maintain it, say that as well.

I agree. I think this is what is missing from other responses. What is the problem?

1. This feature is deemed unwelcome and even the most beautiful patch would be rejected. AKA I don't want to maintain it or the feature is actively harmful.

2. Unsure about this feature, but maybe a good patch would be accepted.

3. The feature is fine, but I have no interest in working on this. Patches are welcome.

I think valuable information to the other person 1. I guess they should go away or fork. 2. Maybe discuss more, maybe find a way to get a patch written. 3. Wait or find a way to submit a patch.

Many people also don’t appear to understand that code comes with an on-going maintenance cost. Even if someone else writes a PR, I may not want to be responsible for that code in future. It’s OK to just say no.

If they won’t pay and you aren’t interested in building the feature I would bluntly state that.

“PR welcome but I will not be writing this personally. Closing for now”

the truth is, pr's might not even be welcome and thats ok. Any code/feature added, even via someone elses PR becomes a maintenance burden on the maintainer.

Remind them they are welcome to fork the project to add what they would like.

I usually just say I will consider it for a future release and I move the issue to discussions.

And maybe one day I will do the feature, but not cause they told me to. :-)

As a user, I would rather you just say <no|there's no plans|it won't be looked at.>

That being said, I'm also a _lot_ more likely to take no as the answer than the entitled person in OPs post.

I think this where some bureaucracy would be in order. Have a list of rules somewhere for the project. Have a list of close reasons based on the rules. One of them will be "Feature Request Declined". With the rule being "If you ask for a feature, we will consider it but we cannot guarantee to implement it, we may close it with Feature Request Declined because of time constraints, priorities or just that the maintainers need a life outside of doing this.".

This might take the emotion out of it.

Honestly I think you should try to state exactly how you feel (F off) in the most professional and non-abrasive way possible. What do you really want to say to this person? Do that.

The important thing is to speak your truth. You don't owe anyone else anything in this life!

Your point of view is very clear: it's not a feature you're interested in. But it doesn't mean that it's not a good feature for the person who has opened the issue.

Instead of convincing them that it's a bad feature or talking about why it's uninteresting to you, just point them to a CONTRIBUTING.md and stop engaging with them after that. If they're actually serious about the feature, they can implement it in their own fork (which then you can request as a PR if you want it in your repo).

There are people like that. They will keep riding you for as long as you keep responding in a polite and reasonable manner.

The tactic is to add progressively larger delays to each response, while make them shorter at the same time. Start with a delay of a couple of days and progress to weeks. This works and it's very effective in discouraging this sort of behavior.

The same works with for new tickets, but you can just close them after a week. Optionally add something like "Dully noted, thanks".

This is probably not best practice but I just throw it in the backlog. There's always too much stuff in the backlog. Maybe theoretically someday another dev will write it and submit a PR. Maybe the requester will.

This doesn't apply as well if it's a feature you actively do not want in the product.

If you'd merge such a feature

- Close issue -> "Feel free to make an implementation and open a PR".

If you'd not merge such a feature

- Close issue -> "Feel free to fork the project and have an alternate implementation"

To me it sounds you don't really know why it's not a good idea, but you are just annoyed by the phrasing of the feature request.

So my advice would be:

1. Relax.

2. Take the emotion out of the equation.

3. Actually try to think about the feature request and why you will or will not implement it.

4. Calmly explain your reasoning based on rational grounds.

I’d agree with this if OP was getting paid, but they’re doing this for free on their own time. If it’s stressing them out, politely say no, and if Pushy Requestor continues to push, block them.

You don’t need to take time to rationally explain your thought process to every random dickhead on the internet.

I have to deal with that frequently and would say, it really depends what you want.

Do you think the issue is useful but you don't want to implement it? Keep the feature request open and say you're open to contributions (or maybe getting paid to implement it).

Do you think it's out of scope and shouldn't get implemented? Say that, close the issue and lock it if people keep discussing.

I can also recommend creating response templates for these things. Be clear and assertive, back and forth wastes everyones time and just leads to more frustration on both sides.

wontfix, close, mute, block.

It is open source, they can always fork it, fix it and do the long term maintenance themslves.

Look at it like this - even big FAANG companies have bots that auto-close issues without discussion. You don’t have to feel bad about closing an issue and locking it.

My responses fall into 3 broad categories:

1. I consider that to be out of scope for this project, but feel free to fork and add it yourself. (Translation: I think it's a bad idea)

2. That's a good idea, I will consider implementing it at some point in the future. In the mean time, PRs are welcome.

3. Sure, I'll implement it now.

If for some reason they keep asking, I respond with something along the lines of "pay me, or go away" (but perhaps phrased more politely, depending on what mood I'm in).

If the feature isn't something on your roadmap, and it is important to you, or important enough for them to contribute brue code themselves, then politely say, "not on our roadmap" and close the issue.

My two cents:

I'm not really interested in adding this. We can discuss the feature further if you're willing to fund it, or to implement and maintain it yourself for the foreseeable future. Otherwise I'm considering the issue closed.

I’m sorry but I’m not willing to implement this feature. Feel free to fork the project and implement it by yourself if you want.

Regards, $YOUR_NAME.

If you don't feel your project needs his request, or you just don't want to do it; give him an hourly rate.

He'll figure it out soon enough, no point in wasting your personal time on a stranger.

"Thank you for your feature request. Submitting thoughtful requests like this takes time, and I appreciate the consideration put in to prepare it.

Unfortunately, the feature request does not align with the goals I've set for this project, and I will not be considering it or any related requests for the foreseeable future. Specifically, I intend to accomplish [your desired outcome of the project] and do not want to reach that goal using the methods you have described.

I sympathise if this is a dealbreaker for you. I have appreciated your patronage up til now, and understand if you need to seek alternative software solutions as a result."

You can follow up with a more "direct" comment if they don't get the message from the above. However this should suffice in most cases.

Huge sense of entitlement showing up on project forums is inevitable. I think it is okay to be open and blunt (and civil) when responding to such posts.

I had ended up codifying [1] my stance around this to a contrib document to quickly link to annoying issues when closing them. Saves the headache of having to write fresh explanations.

[1] - https://github.com/knadh/listmonk/blob/master/CONTRIBUTING.m...

Those contributing guidelines are very well written. I'll borrow them for my projects!

When I started with open source, I was hyped to get any feedback, bug reports, feature requests, and such, and I always tried to do my best to address these.

After 10+ years of maintaining popular projects (e.g., https://nodemailer.com/) and going through thousands of tickets in the process, I mostly ignore the incoming issues and requests now. Is it a clear bug I didn't know about – sure, I'll take it up as soon as possible. Anything else - I'll ignore it, don't even respond anything, and the stalebot will close that ticket in 30 days unless something additional comes up (usually it does not).

No one pays me for it, so I find my responsibilities to end at the point where the software is maintained and works on every supported platform. If someone does not like that, they can always fork the project.

You are free to do whatever you want, but why not explain in your contributing guidelines that this is how you operate? https://github.com/nodemailer/nodemailer/blob/0b78689e5a8641... The text starts with:

"First, thank you for considering contributing to nodemailer! We welcome any type of contribution, not only code. You can help with

QA: file bug reports, the more details you can give the better (e.g. screenshots with the console open)"

It is completely is incongruent with what you have written here. Again, your project, your time, but this is almost tricking people into expecting something that they shouldn't expect. Personally, I have no problem with maintainers using stale bots, but please tell me about it so I can avoid wasting my time on those projects.

Oh, good point, I should probably update it or remove it. That guide was last updated 5+ years ago, I didn’t even rember that it exists and haven’t been following it for years.

Is it a product made by employees of EmailEngine or how does it work ?

Intuitively I would find it super rude if commercial companies just ignore or send people away for open-source tooling that is directly used for their commercial product.

Like when there are Google APIs Python Client bugs and they don't care and just say "no clue, ask someone else at Google"

Nodemailer is a project I started 11+ years ago with no backing. It gets millions of download every week and is used by hundreds of thousand of projects and developers around the world.

EmailEngine is a commercial project I started a year ago and now I use the Nodemailer’s homepage to drive traffic to it. Both are my solo projects, no one else is involved.

Understood.

Your projects are so well done that they gave me the impression that EmailEngine was a VC-backed opportunistic/shark startup that had eaten an open-source project and enslaved its maintainer.

So that's a big compliment I guess :)

I'd go with:

"I'm glad you are interested in the software I wrote! Please keep in mind that I wrote it for my own personal needs, and decided to share it with others. I may add features I find helpful, but adding features I don't believe should go in (even if they are really helpful to others, like you) will bite me in the future, because all code makes the codebase more complex, and I alone will have to support it all."

some suggestions:

- "pull requests welcome" (This is the polite way to say 'fuck off') - "thanks for sharing your feedback, I don't think this is a feature I'm willing to build or support" - "in order to implement this I would need to be compensated" - "no."

caveat: if you say "pull requests welcome", you should be actually willing to consider and merge a potential pull request. If you don't want the feature at all, be clear about that.

First, decide why you don't want this: Is this a "patches welcome" situation where the change is good but not worth your time, or a change that would make the software worse/isn't a good fit?

Then explain that politely but firmly, and don't be afraid to explain that you're a volunteer working on it, so you ultimately make the calls.

If the reporter becomes uncivil, close and lock the issue. If they start being disruptive/filing new issues, ban them.

(You could also offer paid support, but it seems like you already know that this person wouldn't be a nice customer to work for.)

If I think it's actually a good idea, I tell them I'll happily accept a pull request. I've had dozens of feature requests but only once has someone actually taken me up on this.

If I don't think it's a good idea, I'll give reasoning why and close the issue. If they reopen the same thing I'll ban them. Very simple.

Only if you actually intent to merge a good pull request for the feature.

"This feature isn't in my personal to-do list. Remember that this is free work on my part, not a contract between us two. If you wish to have this feature implemented anyway, my basic quote is X dollars per hour, and you will have to pay at least 100 hours upfront."

If they don't stop bothering you after that, just block them.

You may even want to tell them that their feature will be on a separate branch and any maintenance, including merges from the mainline code, will also be for a fee.

Also, if they want to see your reasoning why you don't like the proposed feature, they will also have to pay up, because it costs you time to write that down.

read: https://polite.technology/preview --> "Rejecting pull requests" by Tom MacWright

".... Rejection is hard. There are a few key things you can communicate to soften the blow. Like many of the other things I recommend, the underlying strategy is that you need to be explicit about the positive and emotional parts of an encounter, not just the technical parts. It's simple and easy to deliver a code review, but implicit in that review is the fact that someone took the time to contribute, and that should be recognized as well."

"PRESENT THE WAYS OUT

Rejected pull requests aren't a dead end, so don't make them sound like the end. You should encourage everyone to contribute again, and present their options explicitly:

I'm going to close this pull request, but I hope you can contribute in the future! If you need this change, feel free to maintain a fork. ... "

"Responding to feature requests

Once a project achieves a certain level of success, it will have users, and those users will have additional demands of the project in the form of feature requests. Experienced and empathetic users will state their feature requests precisely and kindly, but others will use an unfriendly tone or imprecise language that doesn't lend itself to a solution.

- The maintainer does not owe their time to anyone

- The maintainer must treat everyone with respect

"

I have a public roadmap, where people request new features all the time (https://trello.com/b/5i4VvOW8). All of people's features are in there, but some might indeed never happen.

When someone asks or requests, my response is: "Right now I'm working on higher priority things, but some day I might get to your request". It satisfies them all the time, since they understand I'm still improving it, just not their thing.

When I was a consultant with better manners than I have now, this was the right response to the constant stream of scope increasing requests on fixed time or budget projects.

“That’s a great idea! I’m gonna write it down here as something for V2.”

The important part is to close the issue. How you do that depends on the nature of the request.

A #someday tag is a mollifying way of saying "Not on the roadmap, don't hate it, not planning to ever look at this again".

The advantage is: it's not an open issue. Flogging a closed issue is widely understood to be antisocial behavior, and opening a variation on a closed issue is open-and-shut rude.

You can ban someone who does this as an ordinary matter of policy, no one will judge you negatively for it.

As long as it's an 'open issue', a certain class of entitled developer will feel free to harass you about it.

If you aren’t ready to say no and risk upsetting people, you’ll ruin both your software and mental health I think.

A workaround to simply saying “no” might be to make extension points or plugin functionality and then lots of requests can be closed with “this is a good idea for an extension but not suitable for the core application, at least not at the current time”.

The suggestions posted here (give a quote, say no, say you are not interested) are part of a larger, useful guideline:

Respond by specifying clearly what would be required for this feature to land in your code.

This can be money, this can be someone stepping up to do it and maintain it, this can be technical requirements under which you can see this go into your framework. Yes, users opening issues are demanding, but as a github repo owner you can ask for anything as well and put up barriers that the user needs to solve to see it happen. They may be motivated too.

Specifying clearly the problems and what is needed to overcome them leads the user to appreciate you more. It will sharpen your thinking on why exactly you are saying no. And sometimes you will be surprised by someone actually making you happy by meeting your requirements.

"Thank you for the proposal but unfortunately it does not fit in the scope and vision I have for the application, and I rather spend time on areas that I believe in.

However if this is very important to you, I can consider implementing it for a fair compensation for my time."

Something like that. And ensure that contract doesn't include lifetime support/maintenance... :)

Say it straight: 'I will not add this feature' or 'I will only add it if you implement it', whatever is the case for you. You could add: thanks for your suggestion or something like that.

That's it. You may give a reason if you want, but don't engage in argument. Just ghost or block them if they persist. Don't have to fight or yell, just let the other deal with their own disappointment. If they misbehave on your project, ban them.

You don't owe anybody anything.

There's no reason to be upset :) I understand it's offensive, but trying to be neutral/detached, and "professional", is IMO the best approach (also, for one's health).

You don't have resources for that (I presume), and clarify this is (IMO) the appropriate, neutral, answer; that's all.

There is also another sneaky approach. You can add that you're open to commercial support, and to contact you in private for the details. I think this is also understandable, but better be careful. This will surely put things in perspective to the user.

(background: I'm a maintaner myself, although I've never dealt with abusive users; I did make it very explicit though, when I didn't have resources, and users were always understanding).

Would you accept it if they did offer a (high quality, fitting the project style etc.) PR?

If so, something I see a lot which I quite like is along those lines - not something the maintainers are interested in (or whatever) so unlikely to be implemented, however high quality PRs will be considered.

Probably you're right, and they'll never offer one. But if you'd genuinely consider and perhaps merge one if they did, I think this is a good outcome for everybody.

(Plus then you can leave the issue open which can be appeasing - and catch others requesting the same - just lock it if necessary as nothing further to discuss without a PR which can be discussed in its own comments.)

Thank you for developing something people think is worth using and for being a nice enough person to feel awkward about disappointing anyone. A charitable assumption is that the requester stumbled on to github and has mistaken it for his computer vendor's technical support channel the way people used to do on AOL. I agree with everyone's advice and would suggest in addition only that you be explicit about your wish list policy in your README. I have such a section in mine but won't post it here because it's probably too snarky for a nice person.

If you are not sure, get the person involved and see how it pans out. If the person requesting can be asked to "do some work" - diagrams, functional spec, mockups, etc, then it shows commitment. Most cases the user might not be interested, so then it fizzles out. If he/she is really passionate about it, it may turn into a good idea since someone is actually giving it proper attention.

For these kind of people, I just stop responding.

I try to respond to every feature request I get, but when people start to argue, and I have nothing to say that moves the discussion forward, I just stop responding.

When they don't get a reply, they tend to forget about it and stop arguing.

The option of not answering, or very later, is often a pretty effcient one

Put that issue in backlog. May be someone will implement it. I don't think it's necessary to be rude in that case. Of course it's up to you, it's your project and you're not owing anyone to do anything.

"I am not planning to implement this, but it sounds like a good idea, feel free to send a pull request"

additionally apply label "PR welcome" and/or close issue

------------

"This feature is out of scope and not planned"

additionally close issue and optionally apply label "declined"

Ideally, you can also drop link to some documented project vision.

------------

Other comments have good hints how you can try explaining things.

------------

Note that on GitHub and any decent platform you can lock discussions and block people. Feel free to use this, you are not hired by them.

Yeah but I guess the issue then becomes, what happens if the PR ever materializes? Would you want to maintain that code now?

"Hi, Sorry but I/we don't have time for this feature, there is more urgent stuff that we need to work on. Also remember that we do this for free. So either do it yourself and make a PR or pay someone to do it, but we won't. Have a great day" close the discussion, if they reopen one, close it again until they get tired is it that hard?

This response comes off as a bit rude and presumptuous b/c it sounds like you’re accusing the Issue creator of saying “you have to make this”. That’s not clear from the OP. It would depend on what they wrote exactly in the Issue.

In the opening post, it sounds like they’re pitching an idea to get on a roadmap. I would let them know where something like the suggestion lands on the roadmap or if it’s too far down to consider.

I wouldn’t shut down an Issue idea like this unless you want to let everyone know you’re not taking any suggestions.

yea you can say fuck off

well politically correct answer is to fork off

they should fork it instead haha

I'm no dev but let's say that my job has a similar issue. The approach that I use focuses on being 1) truthful, 2) clear, 3) polite, 4) concise. In this specific order.

In other words: "Sorry, I'm not going to do this because [insert here the actual reason, not some lame excuse]".

Past that, if that user keeps insisting, the user is being entitled and you should not bother yourself with entitled people.

You can block people on GitHub to stop them from interacting with you or bothering you

I’ve often received positive feedback from software creators in the form of:

“Thanks we will consider it.” Or “Thanks we have passed this on to our developers”

I think that’s a great response without any obligation on either party. People that make a request just want to contribute to the succes of the project because they like it, in my experience.

This request does not align with my roadmap for the project, but you're welcome to fork the code and implement it with your own team.

Github could do well to help here. In LinkedIn for recruiters you have auto responses "I'm not interested" etc. Github could do something similar, possibly with a "mute this conversation" option. And if someone is getting muted a lot maybe it's time to restrict that account or give them some kind of nudge towards improving their behaviour.

Maybe posting a guide to saying you're not interested is a stronger statement than a button? For example, the guide could suggest creating a label that you use when something won't be prioritised given present conditions. Or whatever is the direct-but-not-offensive way to reject a request.

You can simply close the ticket without saying anything, you are not required to do anything if you don't feel like it, and you should not feel bad about it.

I appreciate this approach to the massive entitlement: «Minecraft 1.18.30.04 support will be added to linux April 19, 2023.»

https://github.com/ChristopherHX/mcpelauncher-manifest/issue...

A mate of mine wrote about this a couple of years ago.

> The three F’s to open source development. > Fix it, Fork it, Fuck off.

https://boyter.org/posts/the-three-f-s-of-open-source/

wontfix and close. If you're feeling generous invite them to make a PR. You don't owe anyone an explanation. Let them fork if it suits them.

"No" and then close the issue. Don't give them the idea that they can talk their way out of it.

I try to inform users as much as possible re our boundaries and how we prioritize feature requests within the Github issue template.

I think it helps, but it's not bulletproof.

Some open source software users feel entitled instead of grateful for what they receive.

Rich Hickey's "Open Source is Not About You" essay gives perspective about the creator / maintainer point of view:

https://gist.github.com/richhickey/1563cddea1002958f96e7ba95...

I would offer a polite decline and point the user to the essay.

Yeah maybe, I’ve had a few PRs closed by them with just “Not interested.” as an answer, after spending days chasing some bugs and fixing them. Until this day I don’t know why they were rejected, and have no idea what I did wrong / how I could have improved them.

They’re pretty rude / brash in communication, which is fine, but I wouldn’t look at them for an example of great OSS stewardship.

Create a label “no bandwidth” or “f… off” if you prefer - then close it.

Common, these are only two letters. N and O.

Easy: Just say " My time is not free, if YOU want this feature you need to pay $100000. If you are unhappy with that, do it yourself."

Say "no", block said user. If he needs the software to do things that it currently doesn't he can either fork the project or use something else altogether.

"wontfix"

Then close the issue and ignore it. People are not entitled to your time for free.

I would say: "Feel free to open a PR with the proposed changes".

Because if they want the thing that bad... come to the table with an example. Then you can still reject that. It's not like you're forced to add something to your code you don't want. They can fork the code if they need that so desperately.

Add a section to your README file, detailing your vision, the features you plan to implement and features you plan NOT to implement.

"Thank you for the suggestion. I have decided not to implement it."

Does GitHub provide a way for maintainers to rank features/issues, or allow users to vote for them?

Draw up a quote ?

I mean it’s a bit glib but I’m serious.

This presumes you want to be paid. Many don’t because it means it’s not fun anymore. I’m in that camp.

I would offer them to join the project as a collaborator or just stop responding.

With an attitude like that I don't think I would want them as a collaborator, nor do they seem interested in doing any work.

Thank them for their request, say you're busy, never implement it.

The normal answer would be: thanks, send a pull request if you want.

"PRs welcome".

If the source code is there they can do it themsleves.

Then comes the next issue:

I really don't like this feature and then direction it will take my project, but this guy has spent hours and there isn't anything technically wrong with the code so I cannot reject it for that reason.

Source: been there, done that, someone out there now hates my guts.

Right, so it's much better to scope the change first - responding to the feature request with this. Either it's out of scope or one can talk about what part of it would be in scope. Lots of projects have a policy of "talk to the devs before making big changes".

I would usually indicate negatively on the feature request if I don't believe it's in scope.

“No.”

Then close it. Then ban him if he persists.

There’s no need to waste your time and energy justifying yourself. In fact, attempting to will probably be taken as an invitation to argue, thus wasting even more of your time and energy.

F... off, where "F" stands for "fork".

i'd close the ticket without a response

I think this is a massive issue for both of you and I don't know how we can resolve it.

Because it's an issue for you because you don't have time to work on it and you can't always work for free.

But most people are on the other side. They work for a company and the company want them to use a package. But the package doesn't work or doesn't have the feature they need.

The can't fix it or add the feature because their company don't give them time to read thousand of line of code and fix the bug or even worse, they just don't have the skill for it. What are they suppose to do ? Their company will put pressure on them and they are stuck so they ask you to fix the bug/add the feature.

In the head of the manager the library is "famous", it is suppose to work and thousand of developer are using it. If it doesn't work it's because the company's developer is bad. But it's not his fault too. So everybody is in the same shit.

And it's a very recurring situation. I'm an average python developer, yesterday my task was to add celery to our django project. Celery is an old and massive "famous" project. It is suppose to work. But what happened when you follow the tutorial ? The tutorial doesn't work. What do I say to my manager ? Sorry the project sucks it doesn't work. He will not understand me. I had to follow another tutorial made by someone else and their install guide was different from the official one, and it kinda works. "Kinda" because it didn't work, to start Celery, celery needs to load the django settings. My django settings was using environment variable. It works for all of them except the django.SECRET_KEY. Why ? I have no idea, so I had to hardcoded the secret key in the settings which is not a good solution, but at least it works and I can progress on the feature I have to do.

What am I suppose to do ? Create an issue in celery asking for "please, can you fix your getting started because my company want me to use celery but it doesn't work ? Can you create a tutorial for using celery beat with django because my company want me to use it and I don't know how to do it ?"

Of course I didn't create an issue because I know I will not have an answer and it's always my fault because I can't debug the library for hours to find a solution to the shitty tutorial who doesn't work.

And that's just the type of the iceberg, I use all my day to make it work and I didn't manage to do it. I had to try different package, downgrade setuptools because one package wasn't compatible etc. At the end of the day, my environment was fucked up, django didn't even start anymore and I had to erase my environment and create a new one.

And that's the day of every average developer (so not HN developers). We get angry because nothing work, our company put pressure on use, and at the end, we ask coldly on github for bug fix or feature.

Certainly this sounds like an issue for you and your company, but I don't see why it is an issue for the project and its maintainers. Many companies enter into support contracts with vendors whose solutions they adopt to avoid this very problem. The solution seems simple to me, your company should seek a support contract with the vendor, and if that is not possible, find a different solution for which they can. It is unreasonable to expect anything, especially in a business sense, from anyone who you are not paying to support you.

Because this is an issue with 99% of the companies.

Don't forget you are here on HN with HN developers. 99% of companies will never seek support contract with vendors. That's the reality, developers have to deal with it and get over the struggle. Maintainer have to deal with it too because companies will never change (or at least not in the few months) and get over developers asking for help which have issues with their library.

Your magic word is "scope". Seperation of concerns.

Many requests are probably simply outside the scope of the project, better done in some other way than the requestor wants.

Some others will be legitimate ideas that would be fine but you just don't have the time to do it. For those I just just mark them as as an enhancement and leave the issue open. I basically say "I agree, this would be a good addition" and the issue can sit there open and tagged as "enhancement" forever for all I care. Maybe someday I'll do it, maybe some day someone else will, or maybe eventually the idea will be obsoleted by something else, or not, I don't care.

The more difficult thing is rejecting a bad implimentation of an agreed good idea.

It's relatively easy to decide what jobs your project should and should not try to do, and then say for each issue whether it falls inside or outside that border. It's a little harder to say "This is a fine idea but I can't do it, and I also reject your attempt to do it."

Even that is still doable though. You just say what the problem is and they can address it (or argue their position and successfully change your mind on some point by simply being right about it), or not.

I think the biggest thing, 2 things, is 1 just know what you're about onnyour end, have a clear idea what your thing is for and what it's scope is, so you always know how to tell the invalid ideas from the valid. and 2 be open to discussion regardless. Maybe an idea that you initially thought was invalid, is actually valid. Allow for the possibility that the requestor is a better engineer than yourself, and has ideas that would actually be good to adopt. They still have to successfully argue their position, and if they can't then they can't, but just treating it as a conversation where you and the user are both hashing it out and figuring something out together makes the eventual denial not feel as bad. Or not feel bad at all since if your vision is clear and your reason for denying is valid, you will have conferred that understanding to them and they'll even agree with you in the end.

And for the few that simply don't play nice, by doing your part, you no longer have to feel the slightest guilt or pressure simply ignoring them by that point. You don't have to get sucked into any stressful fights, you don't have to take any of their attempts to criticize your character to heart. If you explained your reasoning, and you allowed them to dazzle you with better other reasoning, and they failed to present any convincing other reasoning, then your hands and your conscience are clean. F'em. Mark the issue as invalid with a summary of what makes it invalid for future reference, and close it. Close all future duplicates with a link to this one unless and until someone provides new info or reasoning.

Close issue. "Won't fix"

Might as well ban some commenter from your project (not sure how Github manages this)

A lot of feature requests are done to gain clout anyway