system
Given the following post, respond as if you're commenting on Reddit:
human
What is your team's practice for new coding standards?

I'm on a small team that has been struggling with communication and formal processes for the last few months while we grow and get more pressure from a growing startup. 

We need a formal code standard process to be able to 1) introduce code standard proposals, 2) decide on whether to implement, 3) make sure the team knows what the code standards are.

My thinking is to have just that: a form of some kind where people can propose them, and every period of time we get together as a team and discuss them (maybe every week or before we start the next sprint). But I was curious if there are any other processes out there that people have liked on their teams.

Edit: for clarity I'm not really asking for "use linting" - we already do that, we also already test builds for PRs and all code goes through code review. I'm asking for if your team has a process or there's a process you've used in the past for code standards that aren't linting rules. E.g. "Single responsibility functions", UI layout, when to put an index on a table, naming conventions, etc. We also do use best practices for the stack when they're available, ie our naming conventions for Postgres come from Postgres best practices -- however, just because *I* know something is a Postgres best practice doesn't mean everyone on the team does, and we need to put that information somewhere. Currently we don't have a process to literally say "Hey this is the best practice for this, let's commit to it as a team" and agree on that and put it in a place everyone can easily find it.
gpt
Use a code formatter. Use a common format across the entire team. 

Use some kind of static analysis tool if the language you work with has one. 

Use types addition if you are working with a dynamic language and find yourself fighting types often. 

Establish a naming convention for common actions. When do you use get vs fetch vs retrieve? When do you use set or make or build? 

Hold sprint post-mortems. What worked well, what didn't. What can stay, what needs changing.

Setup what rough boundaries that is allowed by individuals devs without discussions. A new language feature? New lib? New service? How much refactoring is too much? Write that line in the sand so you don't have devs introducing too much new stuff in code reviews, blindsiding reviewers.

Reduce your API surface. Expose as few functions as possible and make it known that certain functions are called only by internals. Make it easy for other devs to how and where to extend existing functions.