What are you producing? Software Development Artifacts.

There are four main development artifacts that I treat as top level concerns for my teams.  All 4 are required in a "definition of done" and involve some level of input for developers.  They are:

Code
This kinda goes without saying, since this is what the developer produces.  But there are several parts to the "code" artifact.  There is the code itself, which should be high in quality (consistent, simple, and applicable), it should be reviewed by peers, and it should meet the requirements of solving the problem identified.

Unit Tests (Mocked vs Functional)
I believe in the functional safety net that testing provides.  Not only does it ensure that the code is behaving the way you intended it to, but that if something changes and negatively affects that functionality is caught sooner rather than later.  The big problem with testing is that you can get bogged down in the process.  I believe in an 80:20 rule for writing unit tests.  80% of the unit tests that are written should be small in scope and with mocked dependencies.  The key is to make mocked unit tests as easy to write as possible.  20% of the tests written should be functional.  Functional tests often cross classes and more often than not include dependencies.  These are much more expensive to write because of the inter-dependencies required to be available.

Documentation
When I say documentation, I mean internal technical documentation (as opposed to end-user documentation).  Internal technical documentation is the documentation that describes the object hierarchy, interaction points, data model, and thought process used when designing and coding the solution.  This is incredibly important as it forces the developer to explain how things work and in a way validate the design.  In addition, it incredibly helpful for people follow behind the initial development effort and either have to support, maintain, or extend its functionality.  With comprehensive documentation onboarding is greatly improved and gives people that are unfamiliar with the solutions a starting place outside of the code itself.

Status
The last artifact is a Status.  Communication to the organization is incredibly important.  It is amazing how a person's perception is their reality.  In order to ensure that the individual, team, and organization is all on the same page, a status artifact is needed.  This status communicates where in the project or effort we are, what problem we are running into, etc.  Without a consistently communicated status the outside world (outside the developers themselves) will not have a view into the progress being made.

These four artifacts are so incredibly important to successful software development both in the short and long term.  I try to drive this home by enforcing that all 4 are part of my teams' definition of done.