1y ago

Other dev won't follow best practices, is this common?

Hello again, I'm in a situation where the one the senior devs on my team just isn't following best practices we laid out in our internal documentation, nor the generally agreed best practices for react; his code works mind you, but as a a team working on a client piece I'm not super comfortable with something so fragile being passed to the client.

He also doesn't like unit testing and only includes minimal smoke tests, often times he writes his components in ways that will break existing unit tests (there is a caveat that one of the components which is breaking is super fragile; he also led the creation of that one.) But then leaves me to fix it during PR approval.

It's weird because I literally went through most of the same training in company with him on best practices and TDD, but he just seems to ignore it.

I'm not super comfortable approving his work, but its functional and I don't want to hold up sprints,but I'm keenly aware that it could make things really messy whenbwe leave and the client begins to handle it on their own.

What are y'alls thoughts on this, is this sort of thing common?

53 comments

breaks tests
leaves me to fix them during approval
I’m sorry, what? If he broke it, he fixes it. There should be guard rails that prevent him from merging his code until all the tests pass, and you as a reviewer should refuse to even start a code review unless the build is green.
- Exactly, don't even strat looking at a PR that doesn't pass the CI pipeline
- Im quite happy to help fix the tests with someone that is willing. This kinda guy, not so much
  
  Yup. Nothing wrong with pushing up a draft PR and asking for feedback; but definitely need to be an active participant in fixing the issues, not just expect somebody else to do your work for you.
  That does lead to some sticky inter-personal situations though. Like there's people on my team that I trust enough to just rubber-stamp a PR that looks good but doesn't have test coverage etc. Can generally trust those people will let me know if the failing tests uncover some substantial work that needs to be re-reviewed.
  There's other people I don't trust and will insist their build passes before I review it. Once that person notices they're being held to a different standard, it can be difficult (but necessary) to have a conversation about what they need to change in order to earn that trust.

I don't understand why you'd be fixing unit tests he broke during his pr. It seems like he might be bullying you? Maybe discuss with your manager.
- This stuck out to me too. Why are you fixing things on their PR? If their changes broke the tests then they need to make the changes to fix them before merging
- Unless it was directly caused by some code he wrote earlier that wasn't caught at the time, he shouldn't even consider that
  
  even if it is an earlier, yet undeteced bug, whoever found it (in this case, the cowboy), should at least log it, if not open a separate PR to fix it.

I think this is far more common than one would hope. There are many senior developers out there who got their experience in a different time, when test coverage wasn't important in many businesses. Writing test code is hard and it might be that your teammate simply don't know how to do it.
If the tests aren't there at approval time, they will never be there. I think it is perfectly fine to block approval, especially since you all agreed on it.

Yes, it's common. No, it shouldn't be tolerated. Your boss/tech lead/whatever should be involved. Here is what should be done ideally:
not following best practices: you MUST implement merge requests (GitLab, GitHub, etc.) and his code shouldn't be approved which means that his code won't ever be merged in a shitty state. Force 1 or 2 approvals for each MR, and it should not be possible to merge an MR if it has open comments. The boss should ask every day "why is your code not merged yet?" and he'll have to explain why people don't approve his shitty code.
shitty unit-tests: same thing, the boss should show him how to do this, and the MR shouldn't be approved.
breaking unit-tests: it's the job of the CI to literally block MRs that break unit-tests (whether it's code coverage or unit-tests).
leaves me to fix it during PR approval: NO, it's HIS merge request, not yours.
To sum it up: devs must not approve his MRs, the CI must block MRs that break tests.
- Last point is SO painful… I have a coworker that writes so much shitty code OR it straight up doesn’t work… he once submitted a PR that didn’t work when used! Like, I just started the thing and it was utterly broken - both the implementation and the design.
  More so, some of his PRs are a giant nightmare of over engineered crap that he, at some point, doesn’t even understand.
  Worst of all, he gets angry at me for pointing out that either they don’t work or they are a shitty, complex, mess
  Honestly, at some point I started approving his PR and calling it a day; oh we don’t have tests cause reasons, I tried to use TS too but since my boss finds it too complicated we are not using it again for new projects… funny
  
  This thread makes me so grateful for working with competent people.

I'd start rejecting his PRs lol, why is anyone but the original developer fixing his PRs?
- I agree - if the reviewer doesn't have the power to reject prs then they aren't very useful reviews imo.
  
  Right like, if we’re just doing PR reviews to do them ok but don’t I have anything better to do?

Doesn't sound like a senior dev to me. Sounds like someone who thinks they are.
- Yes, well, seniority tends to be defined quite differently by management – compared to how other devs would define it. A senior to them is a person with a certain experience (at least 3-5 years), who has worked on at least a couple of complex projects (no telling exactly what they did there), shows a "can do" attitude, has good feedback from teammates, and last but not least delivers stuff on time.
  Notice how quality of code doesn't come into it at any point.
  Management doesn't know which code is "quality", it's all voodoo to them anyway. A pleasant team member who sounds like they know what they're doing and delivers working stuff is all they need to see.
  Quality of code needs to be defined and enforced on a project-by-project basis (definition of ready, definition of done). If they aren't defined and/or enforced, but delivery still happens on time, it will be hard for a junior to demonstrate a problem. Some experienced managers will recognize it as a problem in the making by accumulating technical debt, some won't (or don't care).
  I would suggest that OP explains the technical debt in impartial terms during sprint review and wash their hands of it. Confronting the other dev directly usually doesn't work well, especially if it's done remotely.

Why are you fixing his PR's? Reject them for now following your own practices and link to the documentation about those practices that the PR violates.
You're not holding up the sprint doing this, he is. As a team, you agreed these practices and everyone needs to follow them. If he refuses, raise it with his line manager.
Either his Line manager will put him in line, or he'll agree that the standards you decided upon don't need to be followed. Take your pick.

It shouldn't be up to another engineer to fix their PRs. They wrote the code, they are responsible for making sure it is in a state to merge. If it's not, request changes and move on to your work.
- Yeah, we comment in places where we see issues, leave tasks, and just mark the PR as "needs work." I ain't touching code in a branch that's not owned by me.
- Soooo much. It's the biggest of red flags to have to fix other's reviews.
  Maybe take it up with managment. Those kind of profile are a hinder for every other devs that are working with them

My opinion: don't sweat it, either way. I know that's easy to say from the outside, but it's still true. Do what you are most comfortable with. It sounds like you have plenty of ammunition if you want to put your foot down & insist on quality practices. Reject PRs that don't meet best practices, and point to the internal docs you have. If the dev reacts angrily, blame the company & say you are worried about getting in trouble.
Or if confrontation makes you more uncomfortable, just let it slide. If the shit hits the fan, the senior dev is the senior dev. Just say you were following their lead.
Above all, remember that the company you are working for is not your friend and not your ally. Look out for your own interests first & don't stress about work as much as possible (I get that's easy to say and tough to do, but it's still the best idea!)

It’s not called ‘PR Approval’ it’s called PR Review for a reason. Developer should fix broken test especially if there’s super fragile stuff involved ( and that should be fixed asap).
- Yup. Just add a comment that says "add tests for this" on lines of code that needs it in the review. If your dev ends up taking a couple of weeks to finish it, so be it.

It's easy to become a 10x developer when you skip 90% of chores and let other devs doing them for you. If you keep enabling them, they'll become 100x developer soon enough.

Others have given excellent advices. I'll approach it from management point of view:
If there's management oversight, such as tech lead/engineering manager, talk to them. Don't make any accusation. Approach it from the direction of you feeling uncomfortable with how the team is working. They will know how to solve the issue. However, any tech lead/engineering manager should have already dectected the problem and at a minimum acknowledge the issue.
If there's no tech management oversight, I'd suggest you approach the senior engineer directly. I'd want to emphasize here that it has to be tech management. Non tech management won't understand the problem and they won't be able to solve the problem. Sometimes the senior engineer maybe under pressure to deliver and there's nobody to split the tasks to other team members. I did this a few times in my career before I developed my skill to lead a team.
If it's neither because the senior is under pressure to deliver, nor there's management oversight, your next best bet is to seek consultantion with another senior, either in your team or another team. They maybe able help to talk to the senior.
Your last resort would be non tech management, or saying it another way: express that you're not happy with your job. This won't be much help unless others in your team doing so as well.
If all these fail, consider finding another offer. There's no oversight, there's no willing to inprove from the senior and there's no chance to improve the situation from other seniors, you won't learn much there.

Very common.
Don't feel pressured to approve anything you don't want to, but still be chill. It's just work after all. (This duality takes years to figure out, but if you can, you'll be very valuable)
Get the PM involved. Bring it up in retro and stand up.
Examples.
"I don't feel this is PR is up to our company standards. Here's a link to the document. Specifically tests are breaking, coverage is reduced, and your using global variables. If you need help with quality we can code pair next sprint or if I finish my tasks early. Let me know"
"Just a reminder that we have 3 PRs with needs work sitting in the queue. If you're not able to finish them before the end of the sprint, let the scrum master/PM know in case it's a high priority"
"We've all signed off on a standards guideline, and lots of PRs are falling short. Either we need more training time each sprint to reach it, or were going to have to officially reduce our standards. Let me know which one the CTO prefers"

Clear management concern. Good luck! Remember it's only a job

He causes tests to fail and leaves you to fix them?This sounds insane to me. No one should have to fix another engineers problems no matter their level.
- Yeah that’s a major flag for me. If it’s just helping that’s one thing but they’re the senior dev so I’m not sure they should even need the help.

There isn't enough information here for me to say, but this MIGHT be similar to a self-organising dynamic I have seen before.
Maybe there is a dissertation somewhere in the dirth of programming team-dynamic books that has given it a name... But I just think of it like a medieval bulldozer.
Sometimes you have a headstrong dynamo who can and does crush through problems at a FANTASTIC rate. They have strong domain knowledge so everything is functionally correct. There may be some bugs (all code has bugs), but nothing that requires a re-design. But thier velocity is triple or quadruple everyone else's.
But... This comes at a cost of things similar to what you said. A general disinterest for the "small things", a reluctance to break their flow by going back for small bugs they missed. Skimpy test coverage. Since those things HAVE (asterisk) to get done eventually, they tend to pull less experienced devs into their gravity well, and they just end up in thier orbit applying thier full time efforts to patching the holes left behind.
That's why I imagine them like a bulldozer in King Arthur's court. They're just a machine with the capacity to drive a mind boggling amount of blunt work, but require a small army of "finishers" to follow behind to add the finesse after the violence.
A few questions I would be mulling over and asking myself if I were in your situation:
Is this guy able to ship features orders of magnitude more quickly than his peers (regardless of style metrics?)
Does management seem to be aware but unconcerned?
If so, this is probably your situation. Your managers have a bulldozer and they figure it's more effective to just let him do it and have you clean up after him.
It's ACTUALLY a pretty sweet gig if you're getting compensated well. You're shielded from needing to make tough decisions, design decisions. You're shielded from time crunches.
But... It's maybe not super fulfilling. You might resent being in the shadow. You maybe want the opportunity to stake your own claim rather than just riding in this other person's wake.
If that's the case, I'd generally follow the advice given by others here... But make sure you truly understand the management dynamic before you start making moves that are too bold (such as, say, blocking PR merges that by convention were being merged in the past without anybody seeming to mind)... Because if right now management doesn't see a problem, and you start refusing to merge PRs management will suddenly see a problem on their radar, and that problem will be you.
Honestly a frank discussion that you feel like your talents would be better applied to your own parallel work tasks rather than tagging behind the bulldozer in serial is probably the best way to go. You don't need to shit on or diminish your coworker in order to plead your own case.
The truth is, as much as everyone in this conversation will hate to hear it, there is probably something you can learn from this person... If only how they were able to bend their environment so effectively into what they wanted
- I've seen this play out a couple time. I agree about a lot of what you said and this is indeed true that you can have very senior and very knowledgeable devs basically "hack" or "bulldoze" their way into a backlog, I would personally argue that this is not a decent or desirable behavior.
  There is no such thing as "small finition". Making sure that a change or a feature works all the way through is not finition, it is core to the task, and you can't expect someone else to digest and do the latter half of the work without being in your head.
  I guess I am too lazy to type out all the examples with the downfall, but basically if you allow this, you will be shielding a senior from his own butched work, and lets be honest, most people who do this skip the "boring" work for their own selfish reasons. If they want to split the task and have you fix the tests, have them spell it out and justify it.
  Management might not understand what is going on, all they might see is a superstar flying through the backlog, while everyone else struggle because they're constantly fixing this guy's shit. This rarely lead to good engineering, or team dynamic, or team management, and of course you end up with this one guy claiming credit for so much shit, while other team members stagnate. Unfortunately appearance is a thing in dev work, as much as I wish it wasn't.
  
  I've seen this play out many times, but only once was it good. BUT ONCE I did see it be good. It was interesting enough that I took the mental notes of why it worked. Huge asterisk because there are still pitfalls around the team having a single point of failure, but that's an issue with many other modes with mixed skill.
  Anyhow:
  -The whole team was bought into it as a working mode
  -There was a QA embedded directly into the team
  -The bulldozer was forced, but willing, to routinely re-communicate plans and issues
  -The bulldozer became good at proactively communicating "hotspots"
  -The bulldozer was not allowed to do estimation, the surrounding team did that.
  -The bulldozer agreed to be obligated to prioritize helping the team if they had questions (I think this is what helped him to be so proactive... He was incentivized to avoid this scenario of confusion entirely)
  Anyways... I still don't recommend it. But, assuming people are into it, I think there are ways to arrange the right individuals into teams in a way that minimizes the major pitfalls. I'm a pretty big fan of letting/helping teams self-organize into whatever their efficiency maximum is.

That’s definitely not senior dev behaviour, was he also involved in defining the best practices? If so he should 100% be following them as an example to other devs, and if he has an issue with individual parts (which is fine) he should discuss with the team about changing them.
Aversion to tests is also a really concerning problem I would say. And you should not have to fix his code in PR, it’s his code!! I’m afraid I don’t have any answers for you but you are right to find this unusual!

80% of programming is maintaining existing code. His fragile code will be a problem in the future. This is not good .

It's reasonably common.
Teams fail together, even if it is the fault of an individual. Use your voice and don't approve PRs if you don't believe they are production ready.

There are no complete, general statements that can be made about testing in all cases. How much converge and distribution of unit vs integration or white box vs black box, can not be generalized to all cases. The same is true of code practices.
However, policy can be black and white. And if the policy is to test or code with a specific style, then you need only point to that guidance and reject the patch. No confrontation or negativity needed. “This doesn’t currently meet policy x. Please fix and notify.” A respectable senior will appreciate that, and if they don’t they aren’t.

If you’re following agile it is important for a team to agree on a definition of done for a story. If you don’t have one ask the scrum master to start that conversation or bring it up in a retro. One of the things that everyone can usually agree on is that the tests pass. Throw in a minimal coverage threshold as well. It’s not an indicator of good tests but it will tell you when there isn’t enough.
You mentioned that you’re doing this work for a client and that they will take over the code. Verify with management (in your company) if there are any quality measures specified in the contract. You don’t want your guy not performing up to the client’s expectations and you having to put in a lot of last minute nights and weekends to get there.

I would say it's how most softwares are done. And no, it's not a good thing, and you should do what you can to improve things.
My boss and his boss told me that it is impossible to keep documentation up to date and too expensive, which is why we don't have any. Let's say I'm not the most engaged worker there now.

I had this happen with a mid level guy (who thought he was a senior) with a cowboy attitude towards code. After many attempts to reason with him, I revoked his permission to touch the main branch and stopped reviewing his code until he started behaving. He left soon after.
In your case with a senior I'd escalate the situation to management.

This sounds like the story of how I got into CI/CD ….
I was working for a startup, and leadership was amazed at how “productive” this one developer was, changing thousands of files in marathon coding sessions. I realized he knew how to use the refactoring functionality in his IDE. More importantly, I was the QA peon tasked with being first one in every morning to characterize stability before everyone else started working. This guy and his antics made my life miserable.
However, I created build and test automation, and scheduled it nightly (this was before CI was a thing, before we had good tools), so now everyone got emailed the state of the product first thing every morning.
This diva was the only one making changes so all the instabilities were owned by him. Made my life much easier and helped our product get much better. More importantly, it did knock him down a peg, as the side effects of the scope of hos changes became more clear
- I'm that dude on my team when it comes to SQL. Everyone on my team (in my whole company, it seems) follows zero formatting standards when writing SQL code. Nothing qualified, no indentation, no query hints or anything to optimize. People just get their sprocs and views into a state of "good enough" and just hit submit.

I'd go for 1 on 1 discussion first. Understand their view. I assume you already tried.
Next level is a team discussion and understanding the team view. If you have sprints I assume you also have Retrospective. That's what it is for.
It's also not only for objective criteria and weighing cost and benefit, risk and effort reduction. It's also about you feeling comfortable with what you approve and ship. Even if not on a general level, at least in the project context with risks laid out and accepted.
Do you have a lead? Where I work senior indicates expertise through experience, with some decision making and guidance expertise. But lead would decide on direction or what is acceptable if it's not obvious or decidable on a collaborative team level.

I'm not super comfortable approving his work, but its functional and I don't want to hold up sprints...
I know it's not the point of your post, but this is a red flag to me. If you're using scrum (which it sounds like you are?), a sprint isn't defined as "when all the stories get to done", it's a set block of time (generally between 2 and 4 weeks). If the stories don't get to done in the time period, you don't hold up the sprint - they just didn't get to done. Most teams will just refactor the story into smaller pieces to carry over to following sprints.

He is either over-worked and doesn't have time to abide by team standards, or lazy. If lazy, reject the PR for failing to meet standards.
- If over-worked, he needs to talk to his manager or whoever the work is coming from and tell them they need to slow it down

Have a private conversation with him about this. Keep in mind that part of being a senior is knowing when it is ok to skip steps. So rather than calling him out, basically ask him to calm your discomfort by saying how what he is doing is justified.
Unit tests particularly are more helpful in dynamically typed or untyped languages than in typed ones. So if you are using typescript, you can get by with fewer unit tests. You still want good integration tests.
Added: I'm more awake now and see the part about your having to fix his broken tests. THAT is not good, unless you are jointly submitting the PR and a third person is reviewing. Assuming you are fixing the tests in his branch, make sure to comment (matter of factly, not accusingly) in the PR itself that you have fixed test #1, test #2, etc. That leaves some kind of trail that you did some of the work on that PR, which otherwise could be hard to find if you are squash merging so the commit history of his branch is not kept around. Then at evaluation time you can say something like "assisted so-and-so with test coverage on XYZ features". The idea is to avoid conflict but make sure you get credit for your work. Otherwise there is a PR with his name on it and nothing you can point to.
I worked with a cowboy-like dev a while back (very smart guy, knew the codebase like the back of his hand, but was given to hacky shortcuts) and I remember once or twice, I cringed at suggestions he made and said I wanted to be more consistent about datatypes etc. He nodded and understood, so I think I was a good influence.
How does your guy even submit a PR with broken tests? The workflows I'm used to won't let you submit a PR unless the tests pass.
There is a community !ask_experienced_devs@programming.dev that is another good place for this type of discussion.

Sounds like he might be more senior in age than in skill

I've been dealing with similar things over the last few months.
Went through an org restructure, joined a different team and our tech lead was relatively new to the company but has 20yrs experience, sounded good!
Wrong.
Poor communication skills, endless pointless wrappers over everything and even simple things are wildly over-engineered with zero documentation, poor naming and zero tests to verify his homebrew solutions actually work or not.
We go live in 2 months for a nation-wide release. Send help.
- I wonder, what kind of wrappers? I have seen some wrappers that seem useless at first, but they shine when we do a refactor because the wrappers concentrate logic in one place.
  
  the pointless and poorly named kind.
  Here's one example of many:
  dart
  
  class Group extends StatelessWidget { final CrossAxisAlignment crossAxisAlignment; final List children; const Group({ super.key, this.crossAxisAlignment = CrossAxisAlignment.stretch, required this.children, }); @override Widget build(BuildContext context) => Column( mainAxisSize: MainAxisSize.min, crossAxisAlignment: crossAxisAlignment, children: children, ); }
  For those unfamiliar with Flutter, Column is your go-to out of the box widget that's already flexible and simple enough to implement and customize. Group exists purely to set a cross axis alignment value, and by name provides no indication as to what it does or how it lays out its children.
  All that just to save one line to override the default cross axis alignment...

I'm going to play devil's advocate for a moment.
following best practices we laid out in our internal documentation
Are you absolutely sure those "best practices" are relevant or meaningful?
I once worked with a junior dev who only cared about "best practices" because it was a quickly whipped document they hastily put together that only specified stuff like coding styles and if spaces should appear before or after things. That junior dev proceeded to cite their own "best practices" doc with an almost religious fervor in everyone else's pull requests. That stopped the very moment I made available a linter to the project, but mind you the junior dev refused to run it.
What's the actual purpose of your "best practices" doc? Does it add any value whatsoever? Or is it just fuel for grandstanding and petty office politics?
his code works mind you,
Sounds like the senior dev is doing the job he was paid to do. Are you doing the same?
It’s weird because I literally went through most of the same training in company with him on best practices and TDD, but he just seems to ignore it.
Perhaps his job is to deliver value instead of wasting time with nonsense that serves no purpose. What do you think?

53 comments