
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>Demise of the DM Growth Model</h3><h4>14 March 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>If there is no struggle, there is no progress.<em>"</em></p><p>Frederick Douglass</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='demise-of-the-dm-growth-model' href='/Content/Downloads/ARP/ARP240314.pdf'><i class='fa-solid fa-arrow-down-to-line'></i> Article PDF Download</a>
            <button onclick='shareArticle()' value='share'><i class='fa-solid fa-share-alt'></i> Share Article</button><a href='/megatrends'><i class='fa-solid fa-eye'></i> View Megatrends</a></div></div>
<div class='article-page-content__container__right'><div class='article-page-content__container__right__image'><img src='/Content/Images/65f2d64a714407559025789f_iStock-589106782_705x414.jpg#235;article-main-image;705;414' /></div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Fiscal &amp; monetary policy money spent on various crises (% of GDP)</strong><br />
<em>Source: Beutel, Goodman &amp; Company</em></p>
' data-image='/Content/Images/65f2db12a947b58c2983c1e2_Picture1.png#368;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#368;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#368;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#368;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Preface</h4><p>As long-term readers will be aware, we have identified seven so-called megatrends &ndash; trends which will, for many years to come, form both society and financial markets. It is not immediately obvious how to invest in some of those megatrends. Therefore, we have identified a number of associated investment themes.</p>

<p>Take for example the megatrend we call <em>Last Stages of the Debt Supercycle</em>. How do you invest in that? As the name implies, we are late in the current debt supercycle, and that is indeed correct but <em>only in parts of the world</em>. Japan, for example, is in a very different place from most of the rest of the world. The Japanese debt supercycle was the last one to collapse. That happened in late 1989, i.e. the current Japanese supercycle is only 35 years old.</p>

<p>I should point out that debt supercycles are <em>much </em>longer than conventional (cyclical) debt cycles &ndash; on average 65-70 years &ndash; and they always end in (lots of) tears. Insiders call that the panic year, and 1989 was a panic year in Japan, just like 1873 and 1929 were panic years in the US.</p>

<p>--image--</p>

<div>
<p>2008 was widely expected to turn into another panic year in the US, but an extraordinarily benign policy programme post-GFC prevented the disaster. Then, the pandemic struck, and even more money was thrown at the problem (Exhibit 1). The enormity of those two spending programmes bought the Americans some time; however, <em>the US is not off the hook</em>. The panic year will arrive. It always does.</p>
</div>

<div>
<div>
<p>If you want to get a sense of how excessive debt levels are, you typically measure debt as a percentage of GDP. Debt supercycles are different. You measure &Delta;Debt-to-&Delta;GDP instead, i.e. you measure how much debt it takes to create a dollar of GDP. In the early stages of a debt supercycle, debt and GDP grow roughly 1:1 but, as the debt supercycle matures, it takes more and more debt to create a dollar of output. When &Delta;Debt-to-&Delta;GDP gets to approx. 4:1 &ndash; i.e. when it takes about $4 of debt to create $1 of GDP &ndash; you know from experience (all past debt supercycles have collapsed around that level) that the end is nigh; that the panic year is around the corner.</p>

<p>China is the only country worldwide where &Delta;Debt-to-&Delta;GDP is 4:1, but the US is a close second with a ratio of about 3.5:1. I suspect that the mayhem currently unfolding in China is their panic year but only time can tell if I am correct. The underlying economic theory assumes the economy in question is a free market economy, and China is not.</p>
</div>
</div>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#369;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#369;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#369;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#369;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>From megatrends to investable ideas</h4><p>It is quite common for bubbles to form in the latter stages of a debt supercycle. You saw it in Japan in the mid to late-1980s, and you saw it in the US in the years leading up to the panic years in 1873 and 1929. What is happening right now with the Magnificent 7 is a grim reminder of those years.</p>

<p>We all desperately look for reasons to justify the present bubble-like conditions in the US and, in that respect, I am no better than other investors, but the writing is on the wall. The problem from an investment point-of-view is that current bubble-like conditions can last longer than you can afford to go short. I learned that in the second half of the 1980s. Having said that, panic year or not, it will be harder and harder to grow the economy at a respectable pace, and that brings me to the investment theme of today &ndash; the <em>Demise of the DM Growth Model.</em></p>

<p>In truth, until very recently, I called it <em>Demise of the Anglo-Saxon Growth Model </em>&ndash; a name chosen during my years in London. However, as you will see below, it is an investment theme likely to impact the entire developed world &ndash; and indeed some EM countries as well.</p>

<p>In fact, <em>Demise of the DM Growth Model</em> is an investment theme linked to more than one megatrend. Let&rsquo;s quickly go through the logic behind all three cases. First and foremost, it is linked to <em>Last Stages of the Debt Supercycle</em>. As the debt supercycle comes to an end, the speculative forces that have driven risk assets to new heights, thus created bubble-like conditions, collapse. &nbsp;That collapse will hurt the middle classes the most, as a large proportion of their savings is tied up in property and pension savings, both of which will most likely take a significant hit in a debt supercycle collapse. As the spending of the middle classes is the cornerstone of all DM economies, economic growth across the developed world will be negatively affected.</p>

<p><em>Changing Demographics</em> will also affect the DM growth model quite badly. I have written extensively about that before and do not intend to repeat myself. However, you need to be aware (if you don&rsquo;t already know) that millions of workers in DM countries have begun to retire, and that is already having an impact on the worst affected countries (Japan and Korea in Asia and Germany and Italy in the EU). As retirees spend less than working-aged people do, and as they spend their money quite differently, GDP growth is negatively affected, but certain industries actually benefit. Portfolio construction therefore becomes exceedingly important.</p>

<p>The last megatrend that affects the DM growth model is <em>The Rising Gap between Rich and Poor</em>. The rising gap is the result of capital owners taking a larger and larger share of national income and labour less and less. &nbsp;As you may recall, national income can only end up in one of those two pockets &ndash; either the pockets of capital owners or the pockets of labour. Because the propensity to spend the last earned dollar is much lower amongst capital owners than it is amongst workers, the fact that capital owners continue to grab a bigger and bigger slice of the pie affects consumer spending, thus GDP growth, negatively.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#370;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#370;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#370;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#370;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>How to structure your portfolio accordingly</h4><p>If one can assume that:</p>

<p>1. GDP growth will indeed be relatively low in the years to come (as argued above);</p>

<p>2. inflows into risk assets will continue to be strong (which is a fair assumption provided the debt supercycle is not about to collapse); and that</p>

<p>3. the relatively hostile attitude towards foreigners in many DM countries will continue to affect most governments&rsquo; immigration policy programmes;</p>

<p>I would reach the following conclusions:</p>

<p>A. Equities overall will deliver returns below the returns seen in the great bull market of the last 40 years; probably more in line with the average equity returns experienced since 1900, i.e. 5-6% per annum.</p>

<p>B. Not only will returns be much lower than the annualised 11% we have enjoyed over the last 40 years, but they will also be more volatile, i.e. we face an unpredictable mix of good and bad years.</p>

<p>C. If inflows remain high, the industries that stand to benefit from the conditions outlined above will perform significantly better, and most likely deliver attractive absolute returns, than those industries that stand to lose from those conditions.</p>

<p>D. Uncomfortably, high-wage inflation will become a regularly occurring phenomenon, as companies struggle to fill their workforce needs.</p>

<p>One industry that stands to benefit from all of this is the healthcare industry. The elderly catch far more diseases than younger people do, and the elderly spend, particularly in the US, a disproportionate share of their disposable income on healthcare items. As we have learnt more recently, though, not all healthcare companies are winners in the environment currently unfolding. Some have done fantastically well, whereas others have not. That trend is likely to continue.</p>

<p>AI is another big winner, and the worse the demographic outlook is, the more likely the government is to embrace it with open arms. AI can replace a retiring workforce, i.e. keep all wheels spinning, and it can improve productivity. So far, I have tuned in on the so-called hyperscalers and a hardware company or two &ndash; companies that make it all happen. I believe it is still a bit early for companies that have chosen to adopt AI to actually benefit from it.</p>

<p>In the last couple of weeks, I have researched AI&rsquo;s impact on water and electricity consumption and found that AI data centres are massive consumers of both. Therefore, an indirect (and much more reasonably priced) way to invest in AI is to invest in water and/or electricity companies. As far as water is concerned, in principle, we have enough water in the world but only a tiny proportion is potable. Therefore, I prefer to invest in water technology companies &ndash; companies that have developed a technology which can contribute to lower water consumption levels or companies with a technology that can turn non-drinkable water into drinkable freshwater.</p>

<p>Electricity is a different story. Here, the problem, first and foremost, is about years of underinvestment in public infrastructure. To put it bluntly, although governments all over the world are encouraging their countrymen to switch to an EV, should everyone decide to do it overnight, the grid would break down. It simply isn&rsquo;t powerful enough to handle that, and that is the case in almost all countries. Some people argue the only way forward is more renewable energy. Others (like me) argue that renewables, although good for the environment, should never be allowed to stand alone, as wind and solar are not reliable enough to form the basis of your energy supplies (the wind doesn&rsquo;t always blow, and the sun doesn&rsquo;t always shine). The truth, as always, is that we need a bit of everything, so that we don&rsquo;t end up in another crisis like the one in the winter of 2022/23, where the dependence on Russian gas drove energy prices in Europe to absurd levels.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#371;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#371;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#371;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#371;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Include options?</h4><p>As I see the financial landscape in front of me, we can expect decent, but not extra-ordinarily high, returns over the next ten years. Some years will be outstanding (like 2023) whereas other will not (like 2022) and, as mentioned earlier, once the dust has settled, we will probably land somewhere in the mid-single digits as far as annualised returns are concerned.</p>

<p>Adding to that, given that we have enjoyed extraordinarily high returns over the last few months, my near-term return expectations are quite modest. We are effectively in yoyo-like market conditions with good and bad times frequently replacing each other. Now, such expectations warrant a different investment approach. Not only should you target certain industries whilst avoiding others, but you should probably also use options from time to time to protect your portfolio. Here is how I would do it:</p>

<p>When conditions are <em>very </em>benign, i.e. when it is hard to spot a single cloud on the horizon, you buy long-dated 10-15% out-of-the-money put options on, say, S&amp;P 500 (or another index as appropriate). However, <em>only put this programme on when you are struggling to find any negative voices</em>. Put option premia will be low when nearly everybody is bullish and buying them 10-15% out-of-the-money will ensure you don&rsquo;t bet the farm.</p>

<p>That said, buying put options 10-15% out-of-the-money won&rsquo;t protect you against the occasional correction, <em>but that is not why you bought them in the first place</em>. You bought them to protect your portfolio against another 2000-02, 2008 or 2022.</p>

<p>When do you sell them again? Unfortunately, I have seen countless examples of investors sitting on good profits on their put options, only to lose it all again because of inactivity. Just like you have to be tactical on the way in, you must also be tactical on the way out. Just like you bought them when you couldn&rsquo;t spot a single cloud, you sell them again when the entire world, including your taxi driver, tells you that you <em>must </em>sell all your equities. That is, in my experience, the only way to make money on put options.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#372;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#372;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#372;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#372;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Final few words</h4><p>I hope it is clear by now that, although I think market returns will be relatively uninspiring over the next ten years, I believe there will be plenty of interesting opportunities on offer. I am convinced that investors who are prepared to think out-of-the-box can still scoop up attractive returns.</p>

<p>Passive (index) investing is not the way forward, though. We have now entered a regime that will suit active investors far more than index investors. That is essentially why, back in 2018, I wrote a book called <em>The End of Indexing</em>, which you can read more about <a href="https://www.harriman-house.com/endofindexing">here</a>.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>14 March 2024</strong></p></div></div></div>