A few questions and suggestions:
- How are you measuring your output?
- How are you measuring the quality of your output?
- Are you able to extend your software easily?
It's always easy to say that 'We got more stuff done in the past', but without some sort of measurement (including a longer term cost e.g. The quality & extendsibility factors) you don't really know. There are software development methodologies (e.g. Kanban) that offer techniques to measure velocity and output (although it's never an exact science). In short you need to start recording how long it took to build x type of functionality at quality level y and then start measuring against that when you make process changes.
In response to the comments section below - In that case you want to start measuring output directly, even though you're working on different applications yo can still start measuring common units of work, e.g. 'SSO takes us about 3 days to build and we typically get 2 critical defects reported on it' or 'A CRUD screen that works end to end takes us about 4 days to build and we get 0 defects reported back (our Unit and Integration tests rock!)'
- Have you advanced your build infrastructure to Continuous Delivery?
It sounds like your infrastructure is good. But could you deploy to PRD in the next hour if the client wanted it?
In response to the comments section below - Start with good CI practices (Jenkins is a popular x-platform, x-language tool here) and then move to Continuous Deployment for your dev environments (In the Java world, JRebel is great for this) and Continuous Delivery for your test and prd systems. Doing this takes time, but it will pay you back in increased output.
- What development methodology are you using? Is it one of the Agile methodologies such as Lean or Kanban?
I never like to slavishly follow a particular methodology, but I'm currently a big fan of using Kanban as it shows the velocity and output of the team I'm working with. Most crucially it shows you very quickly where the blockages are "Oh look, we're developing the code really quickly, but we're overwhelming QA - so we can either add more QA or write more BDD/ATDD style tests to take that burden off QA".
In response to the comments section below - Whatever fits your team best, but you can measure the individual's and team's output. What's the unit? There is no scientific unit you can use :). You need to build up some historical stats on how long it takes to build something as well as keep an eye on the quality of that work (# of genuine bugs reported & difficulty in extending). I use JIRA and Greenhopper to track this as developers can put in their estimates and then the real time it took them to complete a task. Over time we learn how to split up tasks into 1 day chunks and we can then reasonably accurately measure the output. Please remember this is not an exact science and developers are not production line workers
- Have you got a team of 'smart people who get stuff done'?
- Are the team collectively responsible for issues?
The best teams I've seen always have the peer pressure to maintain a high quality bar through things like static code analysis (Sonar is good here) and peer code/design reviews.
In response to the comments section below - Start with the reporting that CI builds can give you. In the Java world its PMD, FindBugs, JDepend, Code coverage from your tests and many more. Very quickly individuals want to have the highest percentage of coverage, never break the build, least amount of FindBugs warnings etc. Also encourage ideas from the developers on how to improve quality and that sense of working with peers. Lunchtime or later afternoon presentations on a technology and that sort of thing help.
Also, you can encourage a collective approach to resolving issues. Assuming you've got the right culture in place, individuals know when they've screwed up and they also know that the team will work hard to help their colleague get out of the mess. We're all human and make plenty of mistakes after all! In fact dare I say that mistakes should not be punished - sometimes you need to make brave technical decisions that later on don't work out, it's the nature of software development (at times).
There are some people who simply aren't up to being part of a culture like that ('smart and get stuff done'). You may have to find them a niche or simply let them go (that's the harsh realities of business).