DO use the highest possible level abstraction (where you can reuse the specs rather than transcribe manually) for maximal productivity gains

DO focus on obtaining high QoR, equal to hand design (or it won’t get accepted)

DON’T debug in RTL or you will limit abstraction and kill key benefits

DON’T benchmark nor define the flow on small blocks (or it won’t scale and you won’t have productivity benefits)

DO take advantage of the high-level to optimize big things (architecture, system power, etc.)

DO build a hierarchical methodology that will promote IP sharing and reuse (ESL makes that much easier)

DO assume that you will have some architecture awareness in the code but make sure it’s at a high level and DON’T code details (e.g. thread parallelism or micro-architecture) in your application

DO build end to end flow – from algorithm to
physical design

DO build expertise internally, get experts to teach others (company-wide deployment in one push will create confusion and dissatisfaction)

DO plan for what you will want in two and five years from these tools, this methodology is here to stay (otherwise you will be quickly out-of-date and will have wasted efforts)