This has to do with the philosophy. If you want to write bug free programs, and I mean, if you care A LOT about software correctness.
The idea in that case will be that all your functions will have a set of unit tests and generative tests over them that asserts that for most possible inputs they return the correct output.
Once you know that, you know that if provided valid input, your functions are going to return valid output. Because you know your function works without any bugs.
Thus, you no longer need to validate the output, only the input. Because as I just said, you now know that any valid input will result in your code returning valid output as well. So re-validating the output would be redundant.
And this goes one further. After you've thoroughly tested each functions, now you want to test the integration of your functions together. So you'd instrument your app, and now you'd write a bunch of integration tests (some maybe even using generative testing), to make sure that all possible input from the user (or external systems if intended for machine use) will result in correct program behavior and an arrangement of functions that all call each other with valid input.
Once you've tested that, you now also know that the interaction/integration of all your functions work.
At this point you are confident that given any valid user input, your program will behave as expected in output and side-effect.
You can thus now disable instrumentation.
But before you go to prod, you need one more thing, you have to protect yourself against invalid user input, because you haven't tested that and don't know how your program would behave for it. Thus with Spec, you add explicit validation over your user input which reject at the boundary the input from the user of invalid.
You now know there things:
1. All your individual functions given valid input behave as expected in output and side-effect.
2. Your integration of those functions into a program works for all given valid user input.
3. Your program rejects all invalid user input, and will only process valid user input.
Thus you can go to prod with high confidence that everything will work without any defect.
---
Now back to orchestra. Orchestra assumes that you weren't as vigilant as I just described, and that you might have not tested each and every function, or that you only wrote a small amount of tests for them which only tested a small range of inputs. Thus it assumed because of that, probably when you go towards running functional/integ tests, you want to continue to assert the output of each function is still valid, as you anticipate those will probably create inputs to functions that your tests over that function did not test.