Start by writing down what an OS is and what services you want yours to provide.
The main goal is to search the complexity size of the standard PC (as the analog of the basic calculator of computers), PS/2, etc., to completely explain it functionally, like programmed things. Learn each detail by memory, clear, like normal study. If the operating system development kit isn't finished (one that could even be sellable), this is a good way of reviewing all functions to do it fast without doubting. Keyboard functions (controller), nonstandar drivers, full list of x86 CPU functions in existence, present or not. Making references of yearly projects to feed the different subsystems of the OS is a good way to make it advance.
Developing each topic until the end by discussing the effect of certain code from references and correcting (the Wiki, manuals, papers, books, other programs) is also an immediate way to turn knowledge into code. All topics need to include code to work on until turning it into a component. Minimal or middle-sized adaptations to add components may take up to a few weeks, but major components will normally need a year to reach usefulness.
An OS is the basic standard software tool that builds up the functionality of the whole system, like pliers, like defining their whole structure, like doing that for a toolbox, from functionality to visual design.
Given it's a daily use tool, it should be fully open source, and the code itself should answer easily all answers an user has about how it and the programs perform its tasks step by step leaving no doubt about any details.
It needs to emulate standard hardware access and basic devices across platforms, and provide old and new programming interfaces, to take advantage of proven computing elements.
The end result needs to be like a calculator, between hardware and software: Standard, predictable, with standard functions from the x86 PC and other old emulated machines that will never be lost, and on the other hand, that will always be the most important aspect that the system provides (no matter how much the hardware changes or if somebody only knows how to use the basic functions of a computer, the way of programming it with default tools will always be exactly the same).
It needs an amount of emulation that affects the real underlying hardware, as well as implementing the device subsystems from existing OSes for keeping full functionality intact over time.
An OS always has the goal of being regularly useful for daily usage so, no matter the development speed for being fully able to emulate the services of existing OSes with original programming approaches, an OS cannot regard anything as "obsolete" as it is a standard tool with the intention to make evident to the user how it and its applications do their tricks to learn, for example by making logs of the resources of an application as they are invoked, then the user can examine the tasks performed so far by a given application or the kernel itself, along with the system documentation/sources to explain how each resource was employed in a reproducible manner.
In the end it must provide a calculator for standard hardware/software programming, so its basic operations/services/APIs/ports will always be the same and thus it has to be able to emulate any other OS, hobby or big, as its job is simply to be a complex programming calculator with the whole range of computing to explain it at run time.
Ported, own and emulated bootable stand-alone programs without OS designed for bare metal hardware need to be supported natively for standard and driver-based hardware.
There needs to exist a single reference that can be turned immediately into implementation by showing simple and complex dependencies that make possible something as to know exactly what to do to achieve an implementation of each thing in a program.
The OS needs to come with installer/source/documentation discs.
It also needs to be portable, meaning that it should be a simple subfolder in a disk partition with a separate bootloader (from a floppy, CD, USB or removable media/network. It will make it possible for it to coexist with the other OSes like an additional application, without having to uninstall them or having to alter the bootloader (no file system changes must occur for basic execution).
The OS would be cleaner if it is compiled from sources. Besides the base CD images, downloading and compiling specific function versions of the software that will never be deleted from a global GNU/public domain/licenceless owner-less repository would be ideal.
That's exactly what I'm trying to do with my OS. I know it will be cleaner, I will have to keep final versions of all functions for even being able to download and compile my software/OS, never really downloaded as dull ZIPs.