In an ideal world, each new joiner is expected to be trained with the practices and standards applied on the project. Happens that the ideal world is far from reality. When project starts getting off track, is not rare to have more manpower added on it, which is doomed to failure.

Right now, the project is lacking people and a new developer has joined the team. His programming background is known for his low quality. On his first experiences on the team, he demonstrated a lack of a clarity on what he was doing, and if he keeps work like this he'll increase the project's technical debt.

Right now, the first mitigation - which is already proven valid - is the implementation of code review. However, it takes time and dedication from both people involved, which would impact the project plan.

How should this situation be dealt with?

  • 1
    This question may be closed in the near future. I believe there is a valid question within about how to do effective domain knowledge transfer. Trismegistos, recommend you refocus the question around knowledge transfer and specific challenges you're facing in doing it effectively. Aug 11 '14 at 18:18
  • I was that kind of guy many years ago, what saved myself was a book called "Clean Code" by Robert C. Martin 2008, even if the code is Java, the concepts are the some for all languages. Aug 19 '14 at 11:31
  • Hi Trismegistos, I've completely rewritten the question to make it a bit more PM-oriented. Please feel free to roll it back if I missed the main purpose of it / change it as it'd fit better your problem. Tks
    – Tiago Cardoso
    Aug 25 '14 at 19:16
  • Instead of using the new person to only write new code, use them to lighten the work load of the existing developers, e.g. sysadmin, database admin, build engineering, writing unit tests, brewing cappuccinos / gourmet teas (team morale goes a long way), everyone is good at something
    – tsundoku
    Sep 2 '14 at 9:28

It's great to hear that Code Reviews went smoothly and you are seeing results soon, you have seen it's effective and that means the junior programmer is keen to learn (All good stuff)

Few things I would like to suggest which can be done at your end

  1. Good code samples from existing code base - You probably have some star quality code in your existing code base(with expected formatting/styling, naming conventions, well designed & reviewed) . Point this out to your junior developer so he can gauge the benchmark he has to meet.
  2. Static Code Analysis - Invest some time to identify a correct static analysis tool for your project(If you don't have one already). There are tools which help to correct coding style, find tech defects such as cyclomatic complexity & security issues. This could however take time. But a static analysis tool will reduce overhead at code review sessions. Will be useful for the entire team. ( Few examples from java world - checkstyle,Findbugs)
  3. Peer reviews - Can you find at least one more developer at his level? (not skill level but in team structure) If so, you can introduce peer reviews between all junior members before the code is reviewed by a senior. This way there will be less overhead for the senior reviewer. If possible, avoid doing peer reviews for the developer in question only. That might create negative team dynamics. Also it'll be a good learning experience for the whole team.
  4. Code review by Senior/Lead developer - With above steps implemented before reaching this point the overhead will be less.

To summarise above,

  • First we clarify expectations
  • Automate with static code analysis
  • Reduce overhead & increase learning opportunities
  • Ensure quality is met with a final review
  • 1
    I support this approach (+1!). I hadn't heard about Findbugs, and googled about it and I believe worth to mention the difference between lack of conventions, bad practices (which are likely to be the case of the OP) and potential bugs. Each of these items have specific tools to cover them.
    – Tiago Cardoso
    Aug 25 '14 at 19:01

Do Pair Programming. I often find that Code Reviews tend to demoralize people, because you criticize (potentially a lot of) their completed work. Even if you are good at giving feedback and the other one is good at taking it, this will be an issue.

In Pair Programming, on the other hand, you start a task together from scratch. Let him take the lead, listen to how he want's to solve the problem, and make suggestions about how to do it better. Do this for 1 hour or 2, at most. Then he should continue on his own for a while. Afterwards, you can do a code review. You will find that there is much less to criticize this way. And he will feel encouraged, because of that and because of the cooperation. Repeat this ritual and change pairs. After a while, he'll get your values and improve. And in the end, maybe you can learn something from him, too ;)


I would suggest, the new member be involved in testing of existing module rather than coding as this would introduce the new members in existing coding practices and standard. Once the new members has a basic idea of the coding practices, it would be best to introduce the new programmer in programming reports or basic forms.


If you don't have much time (and you do follow the advices mentioned above) then I would book a meeting with him and personally go with him through his code and tell him what you don't like or even better agree on a plan on how to structure/write code on your projects.

This way you can get mutual benefits that can be effective immediately.


I like other answers as they're trying to mitigate your immediate situation and work around your problem.

To expand on those answers if you are Manager / PM and have some authority over what is being done on the project, in my opinion you should seriously assess whether it's worth to keep programmer that is far from your standards of hiring.

Taking into aside problem of being forced to incorporate this person on the team without proper recruitment, possible negative implications on your team of current situation are:

  • Brook's law already mentioned by you
  • Lower overall team productivity due to need of "baby sitting" under performing developer
  • Morale degradation among other team members and higher attrition risk due to the fact that great engineers want to work with great engineers. Accepting person with weak performance takes away sense of eliteness from your team and makes it less compelling for engineers to stay on the team.

As PM / Manager you should start discussion and try to raise awareness of the fact how bad for team dynamics is tolerance of weak performers. Also, surprisingly many Managers in organizations still treat managing knowledge workers like they would be working on factory plant and not on creative work.

Peopleware is unfortunately still valid and more relevant than ever.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.