Sign in

Georg Unterholzner

@georg.dev
318 followers 384 following 179 posts

👨🏻‍💻 Software engineer @Dynatrace 🌐 Web dev and trained data scientist 🍜 Foodie | gym-goer | tech & gaming nerd 🇦🇹 Based in Vienna georg.dev

PostsRepliesMedia
Georg Unterholzner @georg.dev · 23/02/2026
Here's a glimpse of how software engineering is going to look soon. I wanted to spend more time with my newborn daughter and less time sitting in a terminal watching an AI type. So I built kipppunkt/build. Today I'm sharing it. github.com/kipppunkt/bu...
120
Georg Unterholzner @georg.dev · 09/01/2026
Five-minute timelapse shot on a Pixel 9 on my last day of vacation in South Tyrol, Italy. At some point in my life, I'll move back here, get myself the best telescope money can buy, and spend my evenings taking photos of galaxies and nebulas far away.
030
Georg Unterholzner @georg.dev · 03/12/2025
It uses many of GitHub Copilot's capabilities (instruction files, prompt files, some tools & configs) for prompt and context engineering. With that, it's reliably able to one-shot entire test suites in my day-to-day work. See for yourself (select 2x speed):
100
Georg Unterholzner @georg.dev · 03/12/2025
AI-generated unit tests suck. Claude overshoots. GPT-5 is lazy af. No model has proper common sense. I tinkered around for a long time to get GitHub Copilot to actually work as expected. The result is this workflow.
110
Georg Unterholzner @georg.dev · 17/11/2025
Think you're safe because you're in a metro station? Think again! Little Berta up there is watching you. Luckily, she’s nice enough to leave hints on the floor to spare those who paid attention in Stats 101.
"I dare you, human"
000
Georg Unterholzner @georg.dev · 17/11/2025
You'd be mistaken if you thought pigeon droppings on the floor were just a random annoyance. Quite the opposite! They're a real-time heatmap showing you the probability of being hit by pigeon poop at any given spot. And you thought all that statistics knowledge was useless!
110
Georg Unterholzner @georg.dev · 18/08/2025
Sometimes programming just feels too much like Hänsel and Gretel.
const breadcrumbsForChildren = generateBreadcrumbs(children);
020
Georg Unterholzner @georg.dev · 13/08/2025
Basic question but I can't figure it out. How are these two design patterns called? In the first, the component structure is fixed, and behavior is controlled *only* through props serving as config. In the second, an extension point via the children prop allows for more flexibility.
Component structure is fixed, and behavior is controlled *only* through props serving as config.Extension point via the children prop allows for more flexibility.
100
Georg Unterholzner @georg.dev · 01/08/2025
Don't be like me. Don't sleep on @playwright.dev's test steps. It took me 4 years to realize how much cleaner, readable, and debuggable my tests could be. Named steps = better readability, clearer reporting, faster debugging. Check out the before/after!
Playwright: without stepsPlaywright: with steps
020
Georg Unterholzner @georg.dev · 22/07/2025
Agent mode tip: Add clear instructions for automating checks like "npm run lint" or "npm run test". With these in your file, Copilot Agent can run the commands, fix errors, and iterate until all checks pass without constant back-and-forth.
Screenshot from VSCode showing GitHub Copilot Agent asking for approval to run the lint command
100
Georg Unterholzner @georg.dev · 17/07/2025
Stack Overflow, are you alright?
000
Georg Unterholzner @georg.dev · 14/07/2025
Finally!! Grok 4 in GitHub Copilot.
010
Georg Unterholzner @georg.dev · 28/06/2025
Gen Alpha successfully rotted my brain. grid-template-columns: 1fr 2fr; now reads “one for real, two for realz.” My grid is aggressively verified. ✅
Post on X from @matthewcp:
"Is it? display: grid, grid-template-columns: 1fr 2fr; or whatever, that's what you need for typical flexbox usage."
100
Georg Unterholzner @georg.dev · 12/06/2025
This year's Stack Overflow Developer Survey in a nutshell
A screenshot of a single choice question in the style of the StackOverflow developer survey with the following text:

"What will you do next once AI has replaced you as a programmer, life partner, and parent?

- Cry
- Become a goose farmer
- Pray to the AI overlords
- Take out your rage as a StackOverflow moderator"
010
Georg Unterholzner @georg.dev · 11/06/2025
Researchers even handed models step-by-step algorithms (e.g., for Tower of Hanoi). The result: identical failure points. LRMs couldn’t reliably execute prescribed logic—suggesting their "reasoning" is often pattern-matching, not general intelligence.
Line graph comparing reasoning model performance when given solution algorithms versus standard prompts. Both conditions show nearly identical failure points as complexity increases, demonstrating that even with explicit step-by-step instructions, models cannot reliably execute logical sequences beyond a critical threshold.
100
Georg Unterholzner @georg.dev · 11/06/2025
Worst of all, LRMs reduce their reasoning effort as problems get harder. Despite having spare token budgets, they underthink when complexity peaks, like a student giving up on an exam’s toughest question—even with extra time left 😅
Line graphs showing accuracy and thinking tokens vs. problem complexity for reasoning models across puzzle environments. Initially, models spend more tokens as complexity rises while accuracy declines gradually. At a critical point, accuracy collapses completely and token usage decreases unexpectedly, indicating reasoning failure.
100
Georg Unterholzner @georg.dev · 11/06/2025
Large Language Models (LLMs) with "reasoning" capabilities are super hyped, but new research from Apple shows their "thinking" is often an illusion. Beyond a certain complexity, they fail completely. Key points in the 🧵.
Graph showing LLM accuracy vs. task complexity: Standard (non-reasoning) models perform as good as reasoning models at low complexity (but use fewer tokens). Reasoning models excel at mid-complexity. Both fail catastrophically beyond a threshold, with reasoning models showing abruptly shorter traces.
120
Georg Unterholzner @georg.dev · 27/05/2025
Austria is outrageously beautiful.
031
Georg Unterholzner @georg.dev · 18/04/2025
my experience with firebase studio so far 😐
Screenshot of the Firebase Studio AI assistant offering help to fix an error it created
010
Georg Unterholzner @georg.dev · 01/04/2025
rate my setup :)
A monitor and a laptop on a balcony overlooking the South Tyrolean landscape.
140
Georg Unterholzner @georg.dev · 19/03/2025
My learning for that day: the final solution was to use the render props pattern. Kudos to @bhuynh.dev and @taranetz.com for pointing that out. We can even take a step further by leveraging React's `isValidElement` function to support both render props and a standard child component.
import { isValidElement, ReactElement } from 'react';


interface WrapperProps {
  children: ReactElement | ((props: { text: string }) => ReactElement)
}

const MyWrapper = ({ children }: WrapperProps): React.ReactElement => {
  const isRenderFunction = !isValidElement(children);

  return isRenderFunction ? children({ text: 'As render function.' }) : children;
}


export default function App() {
  return (
    <>
      <MyWrapper>
        {(props) => <span>{props.text}</span>}
      </MyWrapper>
      <MyWrapper>
        <span>As normal child.</span>
      </MyWrapper>
    </>
  );
}

// renders to: "As render function.As normal child."
140
Georg Unterholzner @georg.dev · 08/03/2025
Life hack: you don't have to worry that someone could replace you with AI, if you replace yourself with AI.
Roll safe meme. Guy tapping his head.
020
Georg Unterholzner @georg.dev · 07/03/2025
Wow, that was quick.
Google Trends graph showing that the search term "MCP" started gaining traction only a few days ago.
020
Georg Unterholzner @georg.dev · 05/03/2025
Alternatively, I could think of restricting the child components' type (it’s a TypeScript library anyway). Then, I could inject the property into the child, and it would just automagically work. I’ve done this countless times in Angular libs. I'm not sure if this is a thing in React, though. 🤷
Code snippet with the following code:

// my lib:
type InitData = { prop1: string, prop2: number };

const MyWrapper = ({ children }: ReactElement<InitData>) => {
  const [initData] = fetchInitData();

  // inject the prop into the children
  const slots = React.cloneElement(children, { initData });

  return (
    <>
      {/* ... */}
      {slots}
    </>
  );
};

// user repo:
const UserDefinedChildComponent = (props: InitData) => {
  const { prop1, prop2 } = props; // use injected props
  return (
    <ul>
      <li>{prop1}</li>
      <li>{prop2}</li>
    </ul>
  );
};

const UserDefinedParentComponent = () => (
  <MyWrapper>
    <UserDefinedChildComponent />
  </MyWrapper>
);
100
Georg Unterholzner @georg.dev · 05/03/2025
Using a React context, maybe? It feels very idiomatic to React to do it that way, and it leads to a very smooth API. However, I don’t like that now my library suddenly also has to export a context instead of just the component.
Code snippet with the following code:

// my lib:
const MyWrapper = ({ children }) => {
  const [initData] = fetchInitData();

  return (
    <MyWrapperContext.Provider value={initData}>
      {children}
    </MyWrapperContext.Provider>
  );
};

// user repo:
const UserDefinedChildComponent = () => {
  const initData = useContext(MyWrapperContext); // data from context
  return <>{/* ... */}</>;
};

const UserDefinedParentComponent = () => (
  <MyWrapper>
    <UserDefinedChildComponent />
  </MyWrapper>
);
210
Georg Unterholzner @georg.dev · 05/03/2025
The first thing that comes to mind is adding a callback to the wrapper, allowing the user to retrieve the state. However, this feels a bit boilerplate-y. Every user would now have to manually wire the two components together. I’m not a fan of that.
Code snippet with the following code:

const UserDefinedParentComponent = () => {
  const [initData, setInitData] = useState();

  return (
    <MyWrapper onInit={setInitData}> {/* use a callback */}
      <UserDefinedChildComponent initData={initData} />
    </MyWrapper>
  );
};
100
Georg Unterholzner @georg.dev · 05/03/2025
React: passing state from a wrapper component to a child. How? I'm building a library that exposes a single wrapper component. Users of this library add the wrapper to their TSX and nest their child component inside it. The wrapper fetches some data that's relevant to the child component.
Code snippet with the following code:

const UserDefinedParentComponent = () => (
  <MyWrapper> {/* I need to get state from here ... */}
    <UserDefinedChildComponent /> {/* ... to here. */}
  </MyWrapper>
);
310
Georg Unterholzner @georg.dev · 03/03/2025
Good question! For me, it depends on the scope and complexity of the project: - If it's only a few DB calls and low complexity, I'd go with just throwing the error. - If it's a large and complex project, I'd use TypeScript with Effect (see screenshot).
Code snippet with the following code:

```
import { Effect } from "effect";

export function deletePostWithEffect(id: Post["id"]): Effect<never, Error | unknown, void> {
  return Effect.gen(function* (_) {
    const { user } = yield* _(Effect.promise(() => getCurrentSession()));

    if (!user) {
      yield* _(Effect.fail(new Error("You are not authorized to delete this post")));
    }

    yield* _(
      Effect.promise(() => 
        db.delete(postTable).where(eq(postTable.id, id))
      )
    );
  });
}
```
110
Georg Unterholzner @georg.dev · 13/02/2025
Similar story with Chart.js: from not being included in last year's questionnaire to becoming the top choice for data visualization libraries in 2024.
Bar chart showing the usage of different data visualization libraries. The interactive version of the graph can be found here: https://2024.stateofreact.com/en-US/libraries/component-libraries/#data_visualization_libraries
100
Georg Unterholzner @georg.dev · 13/02/2025
Framer Motion has rebranded to Motion and remains the top animation choice. More interestingly, GSAP wasn't even in the questionnaire last year, yet landed in third place this year.
Bar chart showing the usage of different animation libraries. The interactive version of the graph can be found here: https://2024.stateofreact.com/en-US/libraries/component-libraries/#animation_libraries
100
Georg Unterholzner @georg.dev · 13/02/2025
Tailwind CSS remains the undisputed CSS library. Meanwhile, styled-components continues its gradual decline in popularity.
Bar chart showing the usage of different CSS tools and libraries. The interactive version of the graph can be found here: https://2024.stateofreact.com/en-US/libraries/component-libraries/#css_tools
100
Georg Unterholzner @georg.dev · 13/02/2025
Component libraries: shadcn/ui is the hottest React component library of 2024, jumping from 20% to 42% usage in just one year. Radix also showed impressive growth, climbing from 25% to 36%.
Line chart showing the usage of shadcn/ui in relation to other component libraries over time. The interactive version of the graph can be found here: https://2024.stateofreact.com/en-US/libraries/component-libraries/#component_libraries_ratiosLine chart showing the usage of Radix in relation to other component libraries over time. The interactive version of the graph can be found here: https://2024.stateofreact.com/en-US/libraries/component-libraries/#component_libraries_ratios
110
Georg Unterholzner @georg.dev · 13/02/2025
If all you have is a hammer, everything looks like a nail. Almost every second respondent uses React to build static sites. Y'all sure about that? Astro.js anyone?
Bar chart showing the usage of React on different project types. The interactive version of the graph can be found here: https://2024.stateofreact.com/en-US/usage/#what_do_you_use_react_for
100
Georg Unterholzner @georg.dev · 13/02/2025
The React API pain points remain consistent: forwardRef and memo still cause the most confusion. Many developers are still complaining about those hard-to-debug act() errors.
Bar chart showing the most frequently mentioned React API pain points. The interactive version of the graph can be found here: https://2024.stateofreact.com/en-US/features/#main_apis_pain_points
100
Georg Unterholzner @georg.dev · 13/02/2025
I finally found some time to dig into the new State of React 2024 results. Here are the key findings. 👇
Logo of the State of React 2024 survey.
100
Georg Unterholzner @georg.dev · 07/02/2025
Why are you still using moment.js?
Graph: moment vs dayjs NPM downloads (5 years), showing dayjs rising to match moment's popularity. Below a table showing the much smaller bundle size of dayjs.
100
Georg Unterholzner @georg.dev · 14/01/2025
What a beautiful sunset after a week of overcast skies! Taken at the gorgeous #Dynatrace office in #Vienna / #Wien.
View over Vienna during sunsetSunset view of Vienna
030
Georg Unterholzner @georg.dev · 07/01/2025
Me coming back to work today and remembering the bug I was supposed to fix before vacation.
050
Georg Unterholzner @georg.dev · 17/12/2024
There’s still a lot of movement in the AI tools space: - Claude jumped 11 spots to take the 3rd place from Gemini. - Cursor climbed from 15th to 5th place.
Bar chart showing the usage of various AI tools. The interactive version can be found here: https://2024.stateofjs.com/en-US/other-tools/#ai_tools
241
Georg Unterholzner @georg.dev · 17/12/2024
Vitest and Playwright are still on a massive upwards trend among testing frameworks.
Line chart showing the usage of Vitest in relation to other tools over time. The interactive version can be found here: https://2024.stateofjs.com/en-US/libraries/testing/#testing_ratiosLine chart showing the usage of Playwright in relation to other tools over time. The interactive version can be found here: https://2024.stateofjs.com/en-US/libraries/testing/#testing_ratios
150
Georg Unterholzner @georg.dev · 17/12/2024
Astro.js continues its meteoric rise among meta frameworks. Honestly, it's easy to see why. It's a great tool.
Line chart showing the usage of Astro.js in relation to other meta-frameworks over time. The interactive version can be found here: https://2024.stateofjs.com/en-US/libraries/meta-frameworks/#meta_frameworks_ratios
150
Georg Unterholzner @georg.dev · 17/12/2024
Angular’s recent updates are paying off. Usage is almost on par with Vue, and it’s one of the two frameworks people like more this year than last (Vue being the other). Kudos to the teams behind both frameworks!
Line chart showing the usage of Angular in relation to other frameworks over time. The interactive version can be found here: https://2024.stateofjs.com/en-US/libraries/front-end-frameworks/#front_end_frameworks_ratiosLine chart showing the positivity of Angular in relation to other frameworks over time. The interactive version can be found here: https://2024.stateofjs.com/en-US/libraries/front-end-frameworks/#front_end_frameworks_ratiosLine chart showing the positivity of Vue.js in relation to other frameworks over time. The interactive version can be found here: https://2024.stateofjs.com/en-US/libraries/front-end-frameworks/#front_end_frameworks_ratios
140
Georg Unterholzner @georg.dev · 17/12/2024
Dev tools lifecycle in 3 stages: 1. Underground favorite 2. Everyone’s go-to 3. 'We hate it now' React and Jest seem to be firmly approaching stage 3.
2D chart showing the usage and the positivity for various tools over time. The interactive version can be found here: https://2024.stateofjs.com/en-US/libraries/#tools_arrows
260
Georg Unterholzner @georg.dev · 17/12/2024
Only a third of javascript devs have used Object.groupBy(). Surprising, considering it solves such an annoying pain point.
Bar chart showing the usage of object features. The interactive version can be found here: https://2024.stateofjs.com/en-US/features/#object_features
140
Georg Unterholzner @georg.dev · 17/12/2024
At least 40% of devs have already used one of the new .to* methods for Arrays. Looks like they're catching on faster than I expected.
Bar chart showing the usage of different array features. The interactive version can be found here: https://2024.stateofjs.com/en-US/features/#array_features
150
Georg Unterholzner @georg.dev · 06/12/2024
React cannot know what events your web component might dispatch, so it uses a heuristic to derive the event name from the event property you set in your JSX.
Screenshot from the file DOMPropertyOperations.js in the react-dom-bindings package of the react repository on Github with the following code highlighted:

```
if (name[0] === 'o' && name[1] === 'n') {
  const useCapture = name.endsWith('Capture');
  const eventName = name.slice(2, useCapture ? name.length - 7 : undefined);
```
110
Georg Unterholzner @georg.dev · 06/12/2024
The release of React 19 might cause you some headaches, if you're a web component creator who happens to name their component events in camelCase (instead of kebab-case as per convention). Let me explain:
Code snippet with the following JSX code:

```
// ✅ this will work
<my-camera-web-component onimage-capture={handleImageCapture} />

// ❌ this won't
<my-camera-web-component onimageCapture={handleImageCapture} />
```
150
Georg Unterholzner @georg.dev · 05/12/2024
My fellow web developers, where do you stand on this? When passing props from a parent to a child component/function, do you prefer: 1. Passing the object (reference) 2. Passing only the specific values needed?
330
Georg Unterholzner @georg.dev · 30/11/2024
This is truly awful. A 🧵.
A tweet of the researcher Yegor Denisov-Blanch with the text "How do we know 9.5% of software engineers are Ghosts? Our model quantifies productivity by analyzing source code from private Git repos, simulating a panel of 10 experts evaluating each commit across multiple dimensions. We've published a paper on this and have more on the way"

It shows a diagram with the title "How do we measure software engineering productivity?". In the diagram, the code of a software engineer is evaluated by their AI model and by a panel of 10 experts. They claim to have found an "exceptional correlation" between the two evaluation methods.
372
Georg Unterholzner @georg.dev · 28/11/2024
I should come to the office more often.
Picture showing the view over the city of Vienna
040