
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>The Trump Agenda - What four years with Trump in power means for inflation and GDP growth in the US</h3><h4>06 December 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p></p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='the-trump-agenda' href='/Content/Downloads/ARP/ARP241206.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/672bb0c9035ada8fd4120d96_iStock-2158103448_705x414.jpg#252;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#294;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#294;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#294;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#294;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Preface</h4><p>The Republican Party took control of the House of Representatives just as it did of the Senate, i.e., at least for the next two years, President Trump will benefit from a Red majority in both chambers of Congress. As a consequence, he will enjoy sufficient powers to act on most of the promises he made when campaigning recently. That said, one thing is what he says he&rsquo;ll do. Another thing is what he actually ends up doing. You never quite know with Trump and, therefore, the following should be read with that in mind.</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#295;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#295;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#295;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#295;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>A snapshot of (some of) Trump’s recent promises</h4><div>
<p>Below, I summarise as many elements of Trump&rsquo;s policy programme as I can remember. I should point out that I have restricted myself to only including policies of relevance to the economy and/or to financial markets.</p>

<p>It goes without saying that not all policy points below will actually be implemented but that is not my point. The purpose of this exercise is to:</p>
</div>

<div>
<div>
<p>(i) give you a sense of what is on his mind; and</p>

<p>(ii) paint the worst case scenario, should Trump go for the Full Monty. Why I deem it worst case will become obvious later.</p>

<p>In no particular order, I have heard him say the following:</p>

<p>- Reduce the corporate tax rate to 15-20% from 21%;</p>

<p>- Implement a 60% tariff on goods from China;</p>

<p>- Increase restrictions on semiconductor exports to China;</p>

<p>- Phase out imports of essential Chinese goods;</p>

<p>- Revoke China&rsquo;s MFN trade status;</p>

<p>- Implement 10-20% tariffs across-the-board;</p>

<p>- Exit the OECD;</p>

<p>- Remove the US from the WTO;</p>

<p>- Pass the &ldquo;Trump Reciprocal Trade Act&rdquo;;</p>

<p>- Challenge the Fed&rsquo;s independence;</p>

<p>- Offer tax incentives to oil &amp; gas drillers;</p>

<p>- Roll back green energy tax incentives in the Inflation Reduction Act of 2022;</p>

<p>- Reduce or eliminate support to Ukraine;</p>

<p>- Implement 25% tariffs on all goods from Mexico and Canada.</p>

<p>The last one came to light only days ago. As Trump said: <em>&ldquo;On January 20th, as one of my many first Executive Orders, I will sign all necessary documents to charge Mexico and Canada a 25% tariff on all products coming into the United States, and its ridiculous open borders. This tariff will remain in effect until such time as drugs, in particular Fentanyl, and all illegal aliens stop this invasion of our country.&rdquo;</em></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#296;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#296;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#296;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#296;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The US government set-up in short</h4><p>The US Constitution regulates the country&#39;s political institutions and is made up of seven articles. Article I provides Congress with the powers to make laws, including the powers to levy taxes and borrow money. Congress is made up of the Senate (akin to the Upper House in Westminster) and the House of Representatives (the Lower House).</p>

<p>If a ruling president wishes to change the law, both chambers in Congress must support it &ndash; in most, but not all, cases with a simple majority. Having said that, the president can also issue so-called executive orders, which require no involvement from Congress. Under this setup, a ruling president can direct a federal official or agency to engage in a course of action or refrain from a course of action. They are enforceable provided the order is within the president&rsquo;s constitutional authority. That said, there are well-defined limits as to what can be passed as an executive order.</p>

<p>Executive orders have always been used but particularly so when the power on Capitol Hill has been divided between Democrats and Republicans, and the ruling president has found it difficult to implement new laws. An incumbent president has the power to revoke an executive order issued by a predecessor. Likewise, Congress has the power to overturn an executive order by passing legislation that invalidates it. The President may choose to veto such legislation, in which case Congress may override the veto provided two-thirds are in favour.</p>

<p>In the case of Donald Trump, strictly speaking, he won&rsquo;t need to issue (m)any executive orders, as he will enjoy a majority in both chambers of Congress &ndash; at least for the next two years. Having said that, Trump is known to be highly opportunistic/impulsive, meaning that he may still use this instrument, as he won&rsquo;t need to wait for the law to be changed.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Proportion of unauthorised immigrant workers in the US by industry</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/67534244080408e524c4c6c4_67534068467103037f6d613a_Picture1.png#297;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#297;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#297;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#297;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Likely near-term changes to US economic policy</h4><p>The most likely near-term changes are those that can be executed under the executive order mandate and, in that category, tariffs stand out. The list above contains 14 specific policies that Trump is seemingly in favour of pursuing. Six of those 14 require only an executive order to be implemented, and five of those six have to do with tariffs:</p>

<p>- Implement a 60% tariff on goods from China;</p>

<p>- Increase restrictions on semiconductor exports to China;</p>

<p>- Phase out imports of essential Chinese goods;</p>

<p>- Implement 10-20% across-the-board tariffs;</p>

<p>- Implement 25% tariffs on all goods from Mexico and Canada;</p>

<p>- <em>Exit the OECD.</em></p>

<p>Trump is clearly intent on using tariffs as a weapon, and you should expect him to act quickly on that strategy. He is keen to demonstrate that he meant it seriously when he talked about raising them, and it won&rsquo;t require months of preparatory work in Congress, i.e., you should expect tariffs to be raised sooner rather than later. Precisely by how much and vis-&agrave;-vis whom is difficult to say, though. When it comes to Trump, I have learned that what he does is not necessarily predicated on what he says he will do. And he obviously uses the threat of tariffs as a negotiation tactic.</p>

<p>In addition to his stance on international trade, the other cornerstone in his policy programme was/is his attitude towards immigrants, particularly illegal immigrants. It was, to a significant degree, the reason he won the election, and that makes it likely that he will act fast on this matter too. However, deporting illegal immigrants requires plenty of stamina. They make up the backbone of the labour force in many industries (Exhibit 1), i.e. those in charge of carrying out Trump&rsquo;s orders will run into <em>massive </em>headwinds. Thousands of US companies will suddenly struggle to fill the jobs, and that will affect both GDP growth and inflation negatively.</p>

<p>--image--</p>

<p>&nbsp;</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 2a: Projected percentage point change in US CPI from baseline under two scenarios, 2024-40</strong><br />
<em>Source: </em><a href="https://www.piie.com/blogs/realtime-economics/2024/how-much-would-trumps-plans-deportations-tariffs-and-fed-damage-us"><em>Peterson Institute for International Economics</em></a></p>
' data-image='/Content/Images/67534244080408e524c4c6ca_675340934ad7dd162c142d42_Picture2.png#298;slide-image;;' data-alt-text2= '<p><strong>Exhibit 2b: Projected percentage point change in real US GDP from baseline under two scenarios, 2024-40</strong><br />
<em>Source: Peterson Institute for International Economics</em></p>
' data-image2= '/Content/Images/67534244080408e524c4c6c7_675340c58d8b88dcf9089d1d_Picture3.png#298;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#298;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#298;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The overall impact</h4><p>In Exhibits 2a-b, you can see the estimated impact of Trump&rsquo;s combined plans. I could have spent weeks fine-combing Trump&rsquo;s policy programme, which would probably have unveiled other bits and pieces likely to affect the US economy but, in terms of magnitude, tariffs and immigration stand out. Needless to say, Exhibits 2a-b provide a pretty telling picture of the estimated impact on the US economy, should Trump go all the way.</p>

<p>--image--</p>

<p>When producing Exhibits 2a-b, it was assumed that tariffs on US imports from China will be raised by an additional 60 percentage points and tariffs on imports from all other countries by an additional 10 percentage points, which is precisely what he has said he intends to do (until he raised tariffs on anything from Mexico and Canada to 25% only days ago).</p>

<p>--image2--</p>

<p>The low scenario implies no retaliation from other countries (which is highly unlikely), whereas the high scenario implies full retaliation from other countries (far more likely). Adding to that, the low scenario implies that 1.3 million unauthorised, immigrant workers, about 0.8% of the US labour force, will be deported. That number has been raised to 8.3 million, about 5% of the US labour force, in the high scenario. The final number is probably somewhere in between.</p>

<p>As you can see, the impact will be <em>massive</em>. Under the high scenario, inflation will rise more than 7% above baseline (i.e. in addition to what inflation would otherwise be), whereas GDP will collapse (I have no better word for a 10% decline). Such numbers are clearly unacceptable. Therefore, Trump is not likely to go for the Full Monty, meaning that tariffs will most likely be raised less than already announced, and the number of deported immigrants will never reach the 8.3 million assumed under the high scenario in the charts above.</p>

<p>So, what is likely to happen next? Trump is a fabulous marketing person (that&rsquo;s what he does best), i.e., he will most likely put a story together that claims success, even if only a fraction of all illegal immigrants have been deported, and tariffs have been raised far less than promised.</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#299;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#299;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#299;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#299;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Investment implications</h4><p>Conditions for US equities will deteriorate during Trump&rsquo;s stewardship but only gradually, i.e., I do <em>not </em>recommend that you sell all your US equities tomorrow morning. Adding to that, and as I have already pointed out, when dealing with Trump, you can safely assume that what he does is not predicated on what he says he will do.</p>

<p>In other words, the forthcoming tariff hikes may in fact be much less dramatic than one would expect, and the actual number of deported immigrant workers may only be a fraction of the number he has indicated will be deported. Such an outcome will be good news for US equities.</p>

<p>If you take another look at Exhibits 2a-b above, you can see that the inflationary impact is expected to peak in 2026, whereas the GDP impact is only expected to peak in 2028, and the reason is simple. Whereas higher tariffs, which will affect inflation the most, can be introduced almost immediately, it will take years to deport millions of illegal immigrant workers. In other words, the impact on GDP will come later than the impact on inflation. That warrants a multi-stage investment plan.</p>

<p><strong>Stage 1:</strong> This stage represents the first 6-12 months of Trump&rsquo;s stewardship, i.e., we are in 2025, and Trump supporters are still on a high from his election victory. Company managements talk openly about the great prospects for business, mostly because corporate tax rates are about to come down as promised by Trump, and all of this will affect sentiment positively. As the impact on US inflation and US GDP is still minimal, if at all visible, the US stock market performs quite well.</p>

<p>On the negative side, you&rsquo;ll find all those countries at the receiving end of higher US import tariffs, particularly China. Furthermore, US bonds run on empty. Bond investors have a knack for discounting future problems earlier than equity investors and, as a result, bond yields are creeping up. Green stocks are also out of favour, as it is not yet clear precisely what Trump intends to do with the Inflation Reduction Act.</p>

<p><strong>Stage 2:</strong> Sometime in the second half of 2025, the first signs of rising inflation levels become apparent. At first, many investors disregard the signs as noise, but it gradually becomes more and more obvious that this is more than noise. At this stage, it becomes apparent to Trump that an independent Fed is about to ruin his narrative, i.e. he begins to <em>seriously </em>challenge the Fed&rsquo;s independence. After a relatively short period of unsettled markets, it becomes obvious that there is in fact little Trump can do to change the Fed&rsquo;s mandate unless he has a qualified majority in Congress (two-thirds of both chambers) behind him and he hasn&rsquo;t.</p>

<p>At this stage, the negative impact on the rest of the world has mostly played out, i.e. other markets are more or less back to business as usual. Having said that, the party in US equities is largely over by now. Up to this point, only companies that have delivered disappointing earnings have been punished, but that is changing now. Consequently, that days of outsized returns on US equities are over.</p>

<p>The only sectors that deliver attractive returns at this stage are companies linked to commodities that benefit from higher inflation. The obvious &lsquo;Trump trade&rsquo; in this context is oil &amp; gas, but do not assume that oil &amp; gas companies are the only ones to benefit from higher inflation. Many commodities do and, in no particular order, I can think of gold, industrial metals and agricultural commodities.</p>

<p><strong>Stage 3:</strong> We are now in the latter part of Trump&rsquo;s 4-year term, i.e., we are probably in 2027, possibly 2028. The combination of uncomfortably high inflation and muted economic growth has led to what can best be described as stagflationary conditions, and US equities perform in kind. High P/E stocks are being severely punished at this stage, whereas commodity-linked names continue to offer some respite.</p>

<p>You will only deliver attractive returns at this stage, if you significantly overweight commodities, including commodity-linked equities. Equities and commodities go through these long cycles where one outperform the other, and commodities have underperformed equities since early 2009 (see the <a href="https://www.arpinvestments.com/arl/time-to-switch-from-equities-to-commodities">November Absolute Return Letter</a>). This has now changed, and a new cycle has commenced where commodities have begun to outperform equities. &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 3: GS Survey: What do you expect immigration to average in the next administration?</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/67534244080408e524c4c6c1_6753418120af5338d13f26a3_Picture4.png#300;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#300;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#300;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#300;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Conclusion</h4><p>The above is my best guestimate as to how financial markets will behave during Trump&rsquo;s stewardship. There are obviously an almost infinite number of variables in the equation; therefore, it doesn&rsquo;t take much to get things wrong.</p>

<p>One obvious unknown is magnitude &ndash; i.e. how far is Trump prepared to go? As I have already alluded to, should he go all the way, the implications for both inflation and GDP growth will be severe, and that is probably the best reason not to expect that to happen. Even Trump will struggle to muster enough enthusiasm amongst his supporters to embrace a 10% collapse in the US economy.</p>

<p>In a recent survey conducted by Goldman Sachs (GS), although nearly everybody (and that includes the research team at GS) expects the immigration policy to be tightened in the US, only 6% of respondents expect immigration to turn negative (Exhibit 3) during Trump&rsquo;s four years in office.</p>

<p>Net immigration into the US averaged about one million annually before COVID-19, peaked at about three million in 2023 and has declined to an annualised rate of about 1.75 million more recently. That number is broadly expected to decline to less than one million next year. The research team at GS expect the pace to drop to about 750,000 next year and to stay at roughly that level during Trump&rsquo;s reign.</p>

<p>--image--</p>

<p>Having said all of that, given how expensively valued US equities are at present, I remain convinced the long-term outlook for US equities is rather bleak. I might get my timing wrong, and I could overestimate the magnitude of the forthcoming setback, but I very much doubt that US equities can continue their recent journey for much longer.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>06 December 2024</strong></p></div></div></div>