Tractability
Tractability is probably the key quality in a project - assuming you want to maintain a high quality product.
When a problem occurs, can it be easily tracked, or do you have to jump through hoops?
A common symptom of low quality development environment is that it is "nice when it works", but the moment it breaks, the problem can't be easily diagnosed, and everyone ends up pulling their hair in frustration as they run around in circles trying to figure out what went wrong.
You can't create a tractable code base if you just follow "best practices" or text books written by consultants touting techniques to write "clean code".
Static Typing
Static typing is crucial for tractability. It also allows you to refactor without too much worrying - the vast majority of errors will be caught by the compiler.
Error messages
Good error messages are also important. Certain language features (C++ templates) are notorious for terrible error messages. These features are better avoided - no matter what "benefits" they ostensibly provide. Many great programmers who use C++ avoid the std library because of its heavy use of templates.
Development environment
Avoid complicated development environments that require tons of configuration.
It should be very easy to setup a new development environment. That is, it should take as few steps as possible.
Example of a setup with very few steps:
Install the language compiler.
- Ideally without worrying about specific version, because this language's compiler is always backwards compatible, so you can always install the latest version even if the project was started 5 years ago when an older version of the compiler was the latest.
Install the source control tool
Add your credentials to the source control server
Fetch the source code repository into your local machine
Note: it is not good to have a "script" to automate the environment setup. The script can fail and then you have to execute it manually. The presence of a setup script indicates that the setup process has too many steps.
Similarly, it should be easy and painless to run the project locally - at any time - and stop it without much hassle.
Examples of pointless hassles that are endemic in the industry:
You have to fetch code from 10 repositories and compile them separately.
The project is comprised of many sub projects each in a different language.
The compilation process is slow.
Reliance on too many third party tools that have to be glued together for the thing to work.
Many configurations are required to be "just right" for the thing to work but it's brittle and no one really understands what's going on.
Deployment
This section assumes your team is developing a web application that has to be deployed to some server for it to work.
The deployment process should be simple and fast. Every team member must be able to understand how it works.
If you have a separate team dedicated to managing deployments, this indicates the process is unnecessarily complicated.
Deployment should not require a lot of third party tools with many configuration parameters.
The ideal deployment process is "copy the program file over to the server and execute it".