I have a situation at work that I’m not sure how to deal with. I’m guessing there are others within the DEV community who have encountered similar situations and so I’m looking for some feedback on how they've dealt with it.

Going anonymous because I really don’t think the names of anyone involved matter and I don’t think anyone is purposefully trying to do anything wrong per se.

Note: I have replaced my colleague's name with the letter "A" for anonymity

Background

Recently, when working on a big new refactor of a feature, I was responsible for doing the first pass/research into how we wanted to implement it. I did so, and then a second colleague, A, joined. A rewrote most of my code because they thought it'd be "simpler" in an alternative format. I’m not entirely convinced the solution was or is better as there have been a lot of edge cases found since, but that doesn’t really matter.


As part of the rework, A built in a bunch of test cases (good) and then has continually pointed to these test cases and their coverage in a “look how amazing my work is” and “there will be no problems” sort of way. I’m all for testing (and admittedly am bad at getting around to implementing them), so I was initially happy with this development.

However, the first time I tried to run the changes A made, I encountered a bunch of errors (even though all the test cases passed). I pointed them out to A, who fixed them. When more stuff was implemented and more of these magical test cases were added, I ran it again I found a bunch of new errors — a process that's been repeated.

So, two obvious conclusions (...at least to me) :

1. The test cases are not actually testing the code. They’re using data that doesn’t replicate real use cases and has been sanitized to the point that it’s useless.
2. A never actually ran the code outside of confirming that the test cases pass and the service can start. The bugs I've encountered were not edge cases that one may reasonably miss.

The problems haven't ended with the test cases. The new "simpler" version did not do what my original version did. Instead of using my work as a reference, A chose to look at the implementation of the old feature. I told A multiple times the old feature was not an accurate reference because we were making significant changes.

A's implementation ended up not implementing many of the new needed features, while at the same time implementing multiple old features that we no longer want. So I’ve spent a lot of time over the past few weeks catching all these missed pieces and having to get them implemented (again) or removing the pieces we don’t want.

So, it’s not just that the test cases haven’t actually caught any bugs, but that the new solution has been both incomplete, while also doing unneeded work.

During all of this, I’ve generally pointed out these issues directly to A in DMs, keeping them relatively private. However, a result of this is that A has continued to boast about the test cases and his work to the rest of the team, who have continued to be super happy/impressed.

This project has been taking a long time, and I’ve always felt (maybe wrongly) that there’s been a belief that it had been me who has been slowing it down. With the addition of A and some others on the project, it really hasn’t moved any faster (even with these amazing test cases :P), so that has felt like validation that it's not just me.

Anyway, I’m finding that I’m getting increasingly stressed out working on this project. I wanted to use it in an upcoming review to point to the good work I’ve done. But the way it’s been talked about within the team, it feels like most of my work has been dismissed or trivialized, and that A is being seen as the “savior” who came in, fixed it all, and made it way better.

This isn’t the first time that A has acted like something they’ve done is amazing and that others seem to lap it up. It has made for an uncomfortable work environment. A recently was promoted from Junior to Intermediate dev, and I really feel like a lot of this boils down to A’s ego being bigger than A’s actual skills.

Normally, I've been able to push aside and ignore this behavior because my work has been mostly separate. But now it feels like A's work (and attitude) is actively making me look bad.

I keep getting caught up in a "is it actually me who is wrong?" spiral, but then I run the code and find more issues, obvious and fundamental issues — and I find myself getting angry/frustrated all over again!

What I'm wondering...

Does anyone have experience working with colleagues like this? How have you responded? Who do you talk to? The dev? Your manager? Someone else? And how have you talked to these people? What sort of solutions have you found? What's worked? What has NOT worked?

This is an anonymous post sent in by a member who does not want their name disclosed. Please be thoughtful with your responses, as these are usually tough posts to write. Email sloan@dev.to if you'd like to leave an anonymous comment.