
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>Some Thoughts on Productivity Growth - and the Investment Implications</h3><h4>06 February 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>You may delay, but time will not.<em>"</em></p><p>Benjamin Franklin</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='some-thoughts-on-productivity-growth' href='/Content/Downloads/ARP/ARP240206.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/65c269faa275b3e2fc8d2fdf_shutterstock_426441559_705x414.jpg#234;article-main-image;705;414' /></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#373;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#373;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#373;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#373;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>How to define productivity</h4><p>Productivity can be defined in a couple of ways. Usually, when referring to it, it is labour productivity that most people think of, i.e. the output per hour worked. There is a problem with that measure, though. Labour productivity will likely rise sharply, if large amounts of capital are poured into new machines (e.g. advanced robotics), but that doesn&rsquo;t necessarily result in improved economic efficiency.</p>

<p>Consequently, the concept of total factor productivity (TFP) was conceived. It is calculated as the percentage increase in output that is not accounted for by changes in inputs of capital and labour. In other words, TFP is a measure of what share of increased productivity that can be explained by factors other than growth in labour or capital.</p>

<p>Over the past half century, almost two-thirds of the growth in TFP can be explained by technology improvements. It is a better proxy for an economy&rsquo;s return on capital, but it wouldn&rsquo;t be fair to simply replace labour productivity with TFP. They are two very different measures of productivity. In the following, I will focus on labour productivity, and I will do so for three reasons:</p>

<ol>
	<li>&nbsp; The focus of this paper is on the implications of little or no productivity growth and, in that respect, labour productivity is perfectly suitable.</li>
	<li>&nbsp; Labour productivity varies a great deal more than TFP from country to country and may therefore better explain geographical nuances in performance.</li>
	<li>&nbsp; Labour productivity statistics are more comprehensive than TFP statistics, i.e. there is access to more information.</li>
</ol>

<p>One last point before I begin. In the following, I focus on productivity <em>growth</em>, not productivity per se. That said, although I repeatedly mention the fact that productivity growth in many OECD countries is painfully low at present, lists of the most productive countries worldwide continue to be dominated by OECD countries (see for example <a href="https://time.com/4621185/worker-productivity-countries/">here</a>). In other words, the issue is <em>not </em>that many OECD countries are not productive enough but rather that they increasingly struggle to <em>improve </em>productivity. The problem is that productivity growth is getting more and more marginal, as the economy in question matures. That is a problem, because productivity needs to grow to create economic growth, and economic growth is necessary in order to satisfactorily manage the mountain of debt in front of us.</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#374;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#374;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#374;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#374;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The two fundamental drivers of GDP growth</h4><p>In economic theory, total output (GDP) is defined as the total number of hours worked multiplied by the output per hour i.e.:</p>

<p>(i) GDP = Hours Worked x Output per Hour</p>

<p>By applying some simple maths, (i) can be converted to (ii), where &ldquo;&Delta;&rdquo; means &ldquo;change of&rdquo;, i.e.:</p>

<p>(ii) &Delta;GDP = &Delta;Hours Worked + &Delta;Output per Hour</p>

<p>We know that the output per hour equals productivity, and we know that changes to the size of the workforce are virtually identical to changes in the number of hours worked. Therefore, we know that two factors drive virtually all economic growth, namely workforce growth and productivity growth: &nbsp; &nbsp;</p>

<p>(iii) &Delta;GDP &asymp; &Delta;Workforce + &Delta;Productivity</p>

<p>Think of (iii) as a reliable indication of trendline growth, but don&rsquo;t use it to estimate GDP growth from year to year. Although annual workforce changes can be estimated quite precisely over shorter time periods, &Delta;Productivity is a residual factor, which is only calculated ex-post, i.e. once GDP is known. In other words, over shorter periods of time, cyclical factors make &Delta;Productivity jump up and down quite dramatically.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Projected change in working age population in selected OECD countries (2000=100) </strong><br />
<em>Sources: OECD, Statista</em></p>
' data-image='/Content/Images/65c26b8ec654f2ee1784e095_Picture1.png#375;slide-image;;' data-alt-text2= '<p><strong>Exhibit 2: Growth in output per hour worked in G7, various periods</strong><br />
<em>Source: </em><a href="https://www.ons.gov.uk/economy/economicoutputandproductivity/productivitymeasures/bulletins/internationalcomparisonsofproductivityfinalestimates/2021#:~:text=With%20the%20easing%20of%20lockdown,States%20(1.2%25)%20in%202021"><em>Office for National Statistics (ONS)</em></a></p>
' data-image2= '/Content/Images/65c26bcbbf66a419b40ab85a_Picture2.png#375;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#375;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#375;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Why we, more than ever, need productivity to grow robustly</h4><p>Between now and 2050, the workforce will decline in many OECD countries, and we know that the worst affected country (Japan) will experience an annual drop of about 1% (Exhibit 1). That may not sound like a mountain to climb. After all, productivity &lsquo;only&rsquo; needs to grow by about 1% annually in Japan to ensure continued economic growth, but that is precisely where the problem lies. Productivity growth is rather anaemic in most OECD countries, Japan included.</p>

<p>--image--</p>

<p>In Exhibit 2 below, the data covers the entire post-GFC period (2009-21). As you can see, not a single G7 country has delivered annual productivity growth in excess of +1% since 2009 &ndash; not one. Admittedly, US productivity improved dramatically in 2020-21, but those two years were in many ways abnormal because of COVID-19, and one should therefore be careful not to draw too many conclusions on the back of those numbers. For instance, it is quite possible that productivity grew faster in the US during the pandemic, as labour market rules were more relaxed there compared to most other OECD countries. I don&rsquo;t know for certain, but it is noteworthy that US labour productivity actually fell in 2022, as working conditions returned to normal.</p>

<p>--image2--</p>

<p>&nbsp;</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 3: GDP per hour worked, 2022 (2015=100)</strong><br />
<em>Source: </em><a href="https://data.oecd.org/lprdty/gdp-per-hour-worked.htm"><em>OECD</em></a></p>
' data-image='/Content/Images/65c26c1b74abc5b32cd745e7_Picture3.png#376;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#376;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#376;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#376;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Productivity growth in a global context</h4><p>So far, I have focused on G7 and shared with you how anaemic productivity growth is in those countries, but it ought to be said that many countries outside the club of G7 have been able to grow productivity faster (Exhibit 3). As you can see, France is near the bottom worldwide, and Italy is not far from the bottom either. Canada, Japan and the UK are lined up next to each other at the bottom of the third quartile, and the best performing G7 countries, Germany and the US, struggle to make it into the top half worldwide.</p>

<p>--image--</p>

<p>I note that most countries that do well productivity-wise are the more prosperous EM countries, i.e. countries that will most likely be knocking on the door to the OECD in the not-so-distant future. As there is no reason to believe that an OECD membership automatically slows down productivity, the relatively poor showing of many OECD countries is probably a consequence of how difficult it is to continue to improve productivity, as the country in question matures.</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#377;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#377;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#377;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#377;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The link between productivity and profitability</h4><p>Productivity is a term (mostly) used by economists to measure the performance of the overall economy. Profitability is a term (mostly) used by business owners to measure the performance of the companies he/she has invested in. However, the two terms meet, as productivity affects profitability. The higher labour productivity is, more often than not, the more profitable the company is.</p>

<p>A study conducted at Ohio State University (see <a href="https://luxafor.com/the-link-between-productivity-and-business-profitability/#:~:text=A%20study%20conducted%20at%20Ohio,to%20increased%20levels%20of%20profitability">here</a>) has found that each 1% increase in labour productivity leads to approximately a 1% increase in shareholder value. With the link between the two being that explicit, it is no wonder that productivity has caught the attention of many investors.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 4: Share of fulltime equivalent employment exposed to automation by AI</strong><br />
<em>Source: </em><a href="https://www.goldmansachs.com/intelligence/pages/ai-may-start-to-boost-us-gdp-in-2027.html"><em>Goldman Sachs Global Investment Research</em></a></p>
' data-image='/Content/Images/65c26c88bcdf6d87c158f2ed_Picture4.png#378;slide-image;;' data-alt-text2= '<p><strong>Exhibit 5: GS AI scenarios: cumulative adoption</strong><br />
<em>Source: </em><a href="https://www.goldmansachs.com/intelligence/pages/ai-may-start-to-boost-us-gdp-in-2027.html"><em>Goldman Sachs Global Investment Research</em></a></p>
' data-image2= '/Content/Images/65c26cf6d9e2e58aa76c579d_Picture5.png#378;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#378;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#378;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Could AI improve productivity?</h4><p>Could Artificial Intelligence (AI) potentially be a solution to the productivity &lsquo;recession&rsquo;? The short answer is yes. AI is probably going to make millions of workers unemployed worldwide and, as a result, corporate profit margins will improve &ndash; in some cases significantly.</p>

<p>It goes without saying that the impact won&rsquo;t be the same everywhere. In some countries, the legal framework will make AI implementation less straightforward than in other countries. And, in some countries, unions are expected to fight harder than in other countries to protect their members&rsquo; jobs. Furthermore, some countries have a much higher proportion of industries exposed to AI automation than others. Analysts at Goldman Sachs estimate that 15-20% of workers worldwide are exposed to the new technology (Exhibit 4). However, as you can see, it varies dramatically from country to country.</p>

<p>--image--</p>

<p>One should also take into consideration the aspect of changing demographics. In a country like Japan, with a shrinking workforce leading to more and more labour shortages, unions are likely to be less confrontational than unions in some other countries. In fact, I could even see AI becoming the <em>solution </em>to labour shortages in certain countries.</p>

<p>Therefore, it is probably no coincidence that countries like Japan and South Korea are way ahead of Europe and the US in terms of automating factory floors. If you scroll down to Exhibit 5 below, you can see that, in the opinion of the research team at Goldman Sachs, US companies are at the leading edge of AI automation and will continue to be so. I have information which suggest that US companies are in fact <em>behind </em>Japanese and South Korean companies as far as automation is concerned. Admittedly, my information relates to stage one automation (i.e. advanced robotics) &ndash; not to AI automation, but I think it would be a mistake to underestimate the intention of the Japanese and the Koreans.</p>

<p>As you can also derive from Exhibit 5, over the next few years, AI&rsquo;s impact on corporate profits is likely to be relatively modest, as relatively few companies will have installed AI yet. Then, as we move into the 2030s, the impact on corporate profits will become meaningful, as AI is adopted more widely (assuming Goldman Sachs get the timing about right). And, as you can also see, as we approach the 2040s, the impact should begin to fade, as most installations will now be behind us &ndash; at least in OECD countries.</p>

<p>--image2--</p>

<p>&nbsp;</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 6: S&amp;P 500 forward P/E multiples &ndash; market cap. vs. equal-weighted</strong><br />
<em>Source: </em><a href="https://www.goldmansachs.com/intelligence/pages/ai-may-start-to-boost-us-gdp-in-2027.html"><em>Goldman Sachs Global Investment Research</em></a></p>
' data-image='/Content/Images/65c26d46413dff060d19077e_Picture6.png#379;slide-image;;' data-alt-text2= '<p><strong>Exhibit 7: AI stocks vs. equal-weighted S&amp;P 500</strong><br />
<em>Source: </em><a href="https://www.goldmansachs.com/intelligence/pages/ai-may-start-to-boost-us-gdp-in-2027.html"><em>Goldman Sachs Global Investment Research</em></a></p>
' data-image2= '/Content/Images/65c26d8e4eb3b4513dfa8b3b_Picture7.png#379;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#379;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#379;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Where to invest</h4><p>The productivity conundrum can be approached in different ways. One might take the geographical approach and allocate most to those countries where productivity grows the fastest. &nbsp;This approach is based on the assumption that, in those countries where productivity is growing most rapidly, you would also expect corporate earnings to grow the fastest. That assumption is hard to argue against and favours, ceteris paribus, an overallocation to US equities. However, in this case, all else is not necessarily equal, as US equities appear to be much more expensive than equities in other parts of the world.</p>

<p>Are they, though? &nbsp;If you look at a study conducted recently by Goldman Sachs (Exhibit 6), on an equal-weighted basis, US equities trade at 15.9x forward earnings &ndash; very much in line with historical averages and not meaningfully more expensive than, say, European equities. (US equities are always somewhat more expensive than European equities.) This is clearly an indication of how far into the stratosphere US megacap stocks, and particularly the Magnificent 7, have driven US equity valuations.</p>

<p>--image--</p>

<p>However, if one adjusts for that, and that is precisely what you do when you look at S&amp;P 500 on an equal-weighted basis, it becomes obvious that the problem is relatively &lsquo;narrow&rsquo;. I put &lsquo;narrow&rsquo; in inverted commas, because the Magnificent 7 account for nearly 30% of S&amp;P500. Therefore, a sell-off in those seven stocks will probably have a meaningful impact on the overall market sentiment, which is likely to drive the valuation of S&amp;P 493 down as well.</p>

<p>Another approach is to go directly after those companies that are operating at the very frontline of AI implementation. That would include some, but not all, Magnificent 7 companies as well as some other tech companies. Those companies can also be described as near-term AI beneficiaries. In Exhibit 7, you can see how well this group of companies performed in 2023.</p>

<p>--image2--</p>

<p>Alternatively, you go for long-term AI beneficiaries instead. &nbsp;However, as you can see, these types of companies did not participate at all in the 2023 feast, the near-term beneficiaries enjoyed. Companies that stand to benefit the most long-term are companies that are significantly exposed to automation by AI and whose labour costs account for a large percentage of revenues. Those types of companies can typically be found in industries like computer software &amp; services, media &amp; entertainment, banks, insurance and other financial services.</p>

<p>I have noticed that this is a hot topic amongst investors, and I have noticed another interesting angle as well. The argument that has been presented to me is that it is too simplistic to divide the world up in near-term and long-term beneficiaries. There is a third group of beneficiaries as well, which consists of certain types of software companies that will ensure that the new AI software can &lsquo;speak&rsquo; to the existing software on the company platform. In the coming weeks and months, I will do more research on this topic.</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#381;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#381;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#381;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#381;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Final comments</h4><p>Overall, I conclude that the valuation of US stocks, away from the Magnificent 7, is not (yet) a massive problem and that, in the US, one can find AI-beneficiaries that are not ridiculously priced. However, I also believe it would be a mistake to create an AI portfolio consisting exclusively of US stocks. In my experience, Asian companies prefer to award IT mandates to domestic companies, and I happen to believe that AI will be implemented rapidly in Asia. There are two reasons for that. Firstly, the culture in Asia is far more pro-automation than it is in our part of the world. Secondly, without more automation, countries like Japan and South Korea will face rapidly rising labour shortage problems. Therefore, Japanese and/or Korean AI tech companies deserve a place in your portfolio.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>06 February 2024</strong></p></div></div></div>