Providing support for mainstream applications is fundamental for a new/custom OS to have impact in the short and long term. This is generally achieved through the development of a compatibility layer, currently an ad-hoc and unoptimized process that involves a vast amount of unnecessary engineering effort. There is a need for efficient methods to measure precisely what OS features are really required by a given set of target applications, gathering results that can help drive the development of compatibility layers by pinpointing what features should be implemented in priority. In this talk I will present a streamlined methodology to optimize the development of the OS features required to build a compatibility layer in order to support a set of target applications, focusing on the system calls of the Linux ABI. To avoid engineering effort overestimation, we rely on dynamic analysis. The methodology revolves around a tool called Loupe that measures, for every system call invoked by an application processing an input workload (e.g. benchmark, test suite, etc.), which ones really need to be implemented and which ones can be faked/stubbed/partially implemented. Given a set of applications and input workloads, Loupe can compute for a given OS an optimized compatibility layer development plan, aiming to support as many applications as possible, as early as possible. We analyze Loupe's measurements over a wide (100+) set of applications, and demonstrate in particular that the effort needed to provide compatibility is significantly lower than that determined by previous works using static analysis: our study shows that as much as 40-60\% of system calls found in application code are not even needed to successfully run meaningful workloads and even full test suites.