The Evolution of Programming: From Building OS for God to Not Exiting Vim

Level 1: Wizard vs Apprentice

Imagine an old master wizard who can build an entire magical castle overnight, versus a young apprentice who gets stuck in a broom closet and has to yell for help to find the door handle. That’s the joke here, but in coding terms. The big dog on the left is like a master builder who can create anything – he’s confidently coding something huge and impossible all on his own. The little dog on the right is like a newbie who can’t even figure out how to close a simple program without asking for help (almost like a child calling “Mom, I can’t get out!”). The meme makes us laugh because the difference is so extreme: one programmer seems almost superhuman, while the other is adorably helpless. It’s a funny way to show the gap between a very experienced coder and a beginner. Even if you don’t know about the specific tools, you can feel the contrast – it’s like showing a champion astronaut next to someone who can’t tie their shoelaces. The humor comes from the exaggeration: of course, real life isn’t this black-and-white, but seeing it portrayed with these two dog characters makes the point in a simple, relatable way. The big dog’s got everything under control (even doing mythical tasks), and the little dog is overwhelmed by something basic. It’s just like saying “Wow, how times have changed!” in a playful, cartoonish way that anyone can chuckle at.

Level 2: Trapped in Vim

Let’s break down the meme in plain terms. It uses the popular Buff Doge vs Cheems format to compare two types of programmers: “programmers before” (the old-school buff Doge on the left) and “programmers now” (the modern Cheems dog on the right). Each panel’s visuals and captions tell a little story:

• Left Panel – “programmers before”: We see a super muscular Doge (the buff Doge) dressed like a casual ‘90s techie (plaid shirt, cargo shorts, baseball cap and sunglasses). He looks confident and strong. He’s holding a tablet or some device with a blue screen. The text below him is written as if he’s speaking: “sure God. Your third temple will be ready in a sec, in full 640x480. haha, keep the CIA busy for a while, I'm just missing some last tweaks in the HolyC compiler.” This is a humorous exaggeration of an old-school programmer’s confidence and capability.

  Let’s unpack that text:

  • “Third temple … in full 640x480” – 640x480 is a screen resolution from older computers (think late ’80s, early ’90s VGA monitors). By today’s standards it’s tiny (your smartphone has way more pixels!). Mentioning “Your third temple” and 640x480 together is a direct wink at TempleOS, a famously quirky operating system that ran at 640x480 resolution. In TempleOS, the creator (Terry Davis) imagined he was building a temple for God through programming. So buff Doge saying this implies he’s doing something as grandiose as coding a temple for God, and doing it in an old-fashioned graphics mode. It’s a way to signal, “This programmer is so hardcore, he’s literally building God a program in an obsolete resolution!”
  • “keep the CIA busy for a while” – This is a random humorous aside. It references the kind of wild things that legendary or eccentric programmers might say. In the case of TempleOS’s real creator, he often spoke of God and the CIA in the same breath (due to his mental health issues, he believed the CIA was watching him). The meme borrows that bizarre element to amplify the mystique of the buff Doge programmer. It’s like saying, “My coding is so next-level, even the CIA will have to scramble to figure out what I’m up to. Haha!”
  • “just missing some last tweaks in the HolyC compiler” – HolyC is the name of the programming language used in TempleOS. Calling it Holy C (yes, holy as in sacred) fits the whole temple/God theme. When buff Doge says he’s tweaking the HolyC compiler, it means he’s adjusting the very tool that translates code into a running program. In simpler terms, he’s not only writing code, he’s modifying the software that processes code. That’s an advanced task, something only a very experienced or ultra-geeky programmer would do. The phrase is delivered casually (“just some last tweaks”) as if this is no big deal – which makes it funny because, normally, writing or altering a compiler is a pretty big deal! It’s as if a chef said, “Dinner will be ready in a sec, I just need to re-design the oven real quick.”

  So overall, the left panel caricatures an old-school, low-level programmer. He’s the type who codes in C or assembly, understands the machine at a very deep level, and has an insane amount of confidence. The buff Doge’s body and expression (cool sunglasses, relaxed posture) reinforce this: he’s the alpha geek, the “wizard” who can conjure anything with code. He’s also independent – note there’s no mention of help or external tools. It’s just him and his prowess (and maybe God tapping him as a contractor!). This panel pokes fun at how we imagine the programmers of yesteryear or the “legends” in programming: ultra-competent, fearless, maybe a bit eccentric, and doing very technical stuff.

• Right Panel – “programmers now”: Here we have Cheems, a smaller, meek-looking Doge character, representing a modern developer. Cheems is wearing a black t-shirt with the GitHub Octocat logo (the iconic cat/octopus logo of GitHub). That shirt choice signals “I’m a modern dev, I use GitHub,” since GitHub is the central place where today’s developers store and collaborate on code. Cheems is sitting at a laptop, and around him are a few items:

  • The Stack Overflow logo hovering near him – Stack Overflow is a hugely popular Q&A website for programmers. If a developer runs into a problem or error, they often search it and end up on Stack Overflow to find the answer. By surrounding Cheems with the Stack Overflow logo, the meme suggests that today’s programmer leans heavily on it. Essentially, Cheems might have Stack Overflow open on his screen as he codes, constantly looking up solutions or copying code snippets.
  • The Spotify icon (green circle) – Spotify is a music streaming service. Many people, including programmers, listen to music for focus or enjoyment while working. The presence of the Spotify logo implies this modern programmer has background music or needs a comfortable environment to work. It’s a small detail that paints the picture of a typical “coder at work” nowadays: headphones on, favorite coding playlist running.
  • A decorative sign that says “FIRST I DRINK THE coffee THEN I DO THE things” – This is a novelty sign about coffee. It’s styled in a cutesy font, the kind of desk decor or wall art you might see in modern offices or home workspaces. The phrase itself is a playful take on “I need my coffee before I can function/do anything productive.” This highlights two things: developer caffeine culture (it’s a running joke that programmers run on coffee), and the fact that modern devs often like to personalize their workspace with fun, motivational, or meme-y items. The sign adds a comedic touch showing Cheems might rely on a caffeine fix and a motivational quote to get going, which contrasts with buff Doge who seemingly needs no such crutch.
  • Cheems’ expression and posture: he looks a bit anxious or overwhelmed, especially compared to buff Doge. He’s smaller, sitting down in a less confident pose, typing away and looking at the screen.

  The caption under Cheems reads: “help me mommy. i can’t exit vim”. This line is deliberately written in all lowercase and in a somewhat childish tone (“mommy” instead of “mom” or just “someone help”). By phrasing it like that, the meme emphasizes how the modern programmer (Cheems) appears helpless and childlike in this scenario. Now, let’s explain the content of that plea:

  • Vim — Vim is a very famous text editor that runs in the terminal/command-line. It’s been around (in some form, starting as “vi”) since 1976 and is beloved by many advanced users for its efficiency. But Vim has a notoriously steep learning curve for beginners. It doesn’t work like a regular text editor where you can just start typing and use the mouse. It has “modes” (insert mode, command mode), and to exit Vim you actually have to know the right command (:q! to quit without saving, or :wq to save and quit, usually after pressing Esc). If you don’t know that, you can get stuck in Vim, unable to quit because every key you press just seems to do weird things in the editor. It’s such a common stumbling block that “How to exit Vim” became a running joke in programming communities (there are countless memes, Stack Overflow threads, and even t-shirts that say “I escaped Vim”).
  • So when Cheems says “i can’t exit vim,” it’s showing that he’s run into this classic newbie problem. He likely opened Vim by accident (perhaps by typing git commit and ending up in Vim as the default editor for the commit message) and now is panicking because nothing he does closes the program. The cry “help me mommy” exaggerates his helplessness – as if he’s reverted to a child who needs a parent’s help with something basic. It’s comedic exaggeration, of course; normally a programmer would ask a colleague or search the web rather than call their mom! But it underscores how lost he feels.

  In summary, the right panel caricatures a modern junior developer who depends heavily on online help and high-level tools, and who lacks experience with older, low-level tools like Vim. Cheems has access to amazing resources (the internet’s collective knowledge, music, coffee, modern IDEs possibly), yet a simple old-school problem (exiting a terminal text editor) has him utterly stumped.

Now, putting the two panels together: the meme contrasts old-school self-reliance and expertise with new-school dependence and beginner struggles. The left side is basically “Look at this OG programmer, he’s basically a tech superhero,” and the right side is “Now look at today’s newbie programmer, they’re struggling with the basics and need help from everyone (even mom).” It’s an exaggerated generational gap in the developer world. The categories listed, like DeveloperExperience_DX and DevCommunities, are relevant because:

• Developer experience (DX) has changed drastically: older developers had a rougher, more low-level experience (think command-line interfaces, writing code in C, dealing with hardware constraints like 640x480 screens), whereas modern DX is smoother in many ways (Stack Overflow answers, high-level languages, modern comforts like nice IDEs, music, etc.). The meme plays on that difference.
• Dev communities: The way programmers get help has shifted from reading manuals or asking a local expert (old forum or in-person user groups) to instantly searching online communities. StackOverflow is basically the embodiment of the modern dev community where people help each other by posting Q&As. Cheems relying on it implies that nowadays many programmers don’t need to know everything offhand – they can quickly tap into community knowledge. In contrast, buff Doge’s era pre-dates such instant help, so he “just knows” or figures it out himself.
• CLI (Command Line Interface): This is directly represented by the Vim scenario. CLI tools like Vim require memorizing commands and shortcuts. Older programmers often lived in the CLI (using vi/Vim, Emacs, doing everything in text terminals), so they are very fluent in it. Newer programmers might mostly use graphical interfaces (IDEs, text editors like VS Code, etc.) and cloud services, and only touch the CLI for specific tasks. So when they drop into something like Vim, which is pure text mode and keyboard navigation, it’s like being in a foreign country without a phrasebook. The meme captures that culture shock.
• Learning: The learning process for developers has changed. The meme highlights a learning curve issue: the older programmer probably learned via tough, hands-on trial and error (maybe learning assembly first, etc.), while the newer one learns by copying examples and using readily available resources. Neither approach is entirely wrong – in fact, modern learning is accelerated by resources like Stack Overflow – but it creates a different skill set. The meme humorously implies the new generation might miss out on some fundamental knowledge (like how to use Vim or how compilers work) because they can always rely on others’ answers or higher-level tools.

To put it simply, imagine how impressive the left side is versus how relatable/embarrassing the right side is:

• The left side programmer could be referencing a legend — think of someone like Dennis Ritchie (who created the C language and co-created Unix) or any of those early computer pioneers who built entire systems with very limited resources. That era of programmers had to be extremely resourceful. They wrote code that ran directly on hardware, often in machine code or C, and they had to understand how everything fit because there weren’t many layers of abstraction. In the meme, buff Doge might be a bit of a caricature (most real programmers weren’t literally building temples for God!), but it’s symbolizing that mythos of the all-powerful old developer.
• The right side programmer represents a newcomer in today’s world. Many of us have been that person – the first time using a Unix environment and feeling totally lost. It’s funny because it’s true: there’s even a Stack Overflow question titled “How to exit the Vim editor?” with millions of views, which shows how common this problem is. And yes, people have jokingly called out “I can’t exit Vim, send help!” on forums or chats, with humorous exaggeration like “I guess I live in Vim now.” The “mommy” part in the meme text just doubles down on making the new programmer seem like a kid in over his head.

Here’s a side-by-side comparison to drive home the differences:

Programmers Before (Old-School)	Programmers Now (Modern)
Writes an entire operating system or compiler from scratch (e.g. coding in HolyC, a custom C-like language)	Assembles solutions using libraries and copies code from Stack Overflow answers as needed
Directly manipulates hardware & graphics (e.g. making a program run at 640×480 resolution, handling video memory manually)	Uses high-level frameworks and tools (likely doesn’t deal with hardware details at all)
Expert with the CLI and old tools – knows how to exit vim without thinking, and generally “lives” in the terminal	Prefers user-friendly interfaces – might use a modern text editor/IDE and struggles with purely text-based tools like Vim
Learns by reading official docs, books, or just experimenting (hence “RTFM” attitude – relying on oneself and the manual)	Learns by quick online search and community help – if stuck, immediately Googles or searches Stack Overflow for answers
Very self-reliant and hands-on: builds and debugs everything personally (even to the point of eccentricity or mythical skill)	Dependent on ecosystem: uses open-source packages, asks others for help, and takes advantage of comforts like music and coffee to get through coding tasks

Of course, these are stereotypes – in reality, modern programmers can be very skilled too, and old ones also ask for help – but the meme exaggerates them for comedic effect.

So why is this funny? Because it’s showing an absurdly exaggerated contrast that many of us can recognize. It’s the ultimate senior vs junior developer joke. Every senior developer remembers the early days of their career, fumbling with something simple, and every junior developer hears almost mythical stories of the gurus who came before. Seeing those two extremes side by side in such a cartoonish way (buff Doge could build “God’s temple” in code, while Cheems can’t even exit an editor) makes us laugh. It’s basically saying, “Wow, how times have changed!” and also “We’ve all been Cheems at some point (except maybe those rare buff Doges).” The DeveloperHumor tag is spot on: it’s humor by developers, for developers, poking fun at our own field’s evolution and the sometimes comical gaps in knowledge between generations.

And if you’re a new developer and don’t understand some of the references: that’s part of the joke too! For instance, if you’re not sure what HolyC or TempleOS is – that’s okay, it’s pretty niche, and that feeling of “huh, I don’t know that” is exactly how a lot of new devs feel when hearing old tech terms. Likewise, not knowing how to exit Vim is a very common newbie situation. The meme captures that slight cluelessness and the reliance on others to fill the knowledge gap. Don’t worry – eventually you’ll learn these things (for the record, to exit Vim you typically hit Esc key, then type :wq to save-and-quit or :q! to quit without saving, then press Enter). Until then, memes like this are a funny reminder that everyone starts somewhere, and even the buff Doges likely had their “can’t exit Vim” moments early on (they just didn’t have the internet to confess it to!).

Level 3: RTFM vs Stack Overflow

From a seasoned developer’s perspective, this meme hits on the generational gap in programming culture and self-sufficiency. The left side (buff Doge) echoes the “RTFM” era – Read The Fine Manual – where programmers prided themselves on deep understanding and solving problems by digging into documentation or by sheer expertise. Buff Doge embodies that mythic “programmer from before the Internet” who could single-handedly craft a solution to any problem. The HolyC reference isn’t random; it’s playfully channeling the legend of TempleOS and its creator: an almost folkloric example of a programmer who literally built an entire operating system (complete with custom language, HolyC, and unique 640x480 graphics) without needing Stack Overflow or GitHub at all. That’s an extreme case, but it represents how old-school programming often required extensive low-level knowledge. These were the folks writing in C or assembly, optimizing for 640KB of memory, and yes, perhaps tweaking their compilers or writing new ones for fun. They came up in a time when if something broke, you had to fix it yourself – there was no Googling a quick answer in 1985. Many experienced devs today remember having to learn by reading thick manuals or experimenting for hours. When buff Doge says he’s “just missing some last tweaks in the HolyC compiler,” it’s an absurd flex: finishing up a compiler tweak is treated as casually as fixing a typo. That’s hilarious to anyone who’s actually tried to write or modify a compiler – it’s massively complex work. The buff Doge’s blasé attitude and even addressing “God” as a casual client (“sure God, it’ll be ready in a sec”) exaggerate the supreme confidence and capability attributed to veteran programmers. It satirically suggests that programmers of yesteryear were practically tech demigods, communing with machines (or deities!) on a first-name basis, and even toying with government agencies for kicks (“keep the CIA busy for a while”). It’s a loving exaggeration of the old guard who grew up close to the metal and sometimes developed a bit of a lone-wolf or eccentric aura.

On the right side, we have the world of “copy-paste coding” and constant connectivity – the Stack Overflow generation. Modern devs (especially newer ones) often learn by quick iteration: encountering an error, googling it, copying a solution, and moving on. The Cheems character surrounded by the Stack Overflow logo captures that perfectly. Stack Overflow, founded in 2008, became the go-to Q&A site where developers get answers to everything from syntax errors to how to exit Vim. Many senior engineers grin (or groan) remembering all the times they’ve seen a junior engineer’s code filled with chunks clearly lifted from StackOverflow answers (sometimes with the original comments or even the <!-- TODO --> still in place!). The meme’s Cheems is practically drowning in external aids: he’s got Stack Overflow for answers, Spotify for background music, and even a motivational coffee sign to get through the day. This pokes fun at the modern developer experience (DX): cushier and more assisted, but arguably more dependent. The “help me mommy, I can’t exit vim” line is the punchline of dependence. It’s written in lowercase, childlike phrasing to emphasize how helpless the new programmer feels. “How to exit vim” is famously one of the most searched questions by new developers and has umpteen blog posts and Q&A threads about it. It’s the quintessential newbie mistake that seasoned devs joke about (because yes, we’ve all been there at some point). Seeing Cheems cry for his mommy underlines how the modern dev, for all the advanced technology at his fingertips, can be completely stymied by an old-school tool that doesn’t provide instant guidance. It’s a relatable humiliation for any programmer who had to ask a coworker or the internet “uhh... guys, how do I quit this thing?” the first time they opened Vim or nano in a terminal.

The humor works because every developer community shares these stories. We laugh out of recognition. The seasoned folks nod knowingly because they recall a time when mastering Vim was a basic initiation, not an optional skill. They might also recall when music at work meant a radio or WinAMP playlist at best – not an infinite Spotify library – and getting help meant asking a mentor or dialing into a BBS (Bulletin Board System) or reading Usenet posts, not posting a question and getting an answer in minutes. There’s a bit of “Back in my day...” sentiment being parodied here. Older devs sometimes lovingly mock the newbies who panic over a Vim exit or copy code blindly from the web, because it highlights how different learning to code has become. The developer generational gap has real causes: the tech industry has massively expanded, tools have gotten more user-friendly, and collaboration is the norm. You no longer need to manually malloc memory to print “Hello World” – high-level languages and libraries handle so much for you. That’s wonderful for productivity, but it can lead to situations where someone can build a web app without ever touching the command line – until they’re suddenly dropped into one and freeze up.

This meme also satirizes the over-reliance on convenience. The new developer has a support system for everything: an online community for solutions (Stack Overflow), an endless playlist to stay in “the zone” (Spotify), and caffeine motivation literally hanging on the wall (“First I drink the coffee, then I do the things” – a kitschy sign you might actually see on a junior dev’s desk or mug). The coffee sign specifically pokes fun at the modern office/developer culture where people adorn their space with quirky quotes and rely on coffee as fuel. Meanwhile, can you imagine the buff Doge caring about a cute sign or needing a latte to code? He’s depicted as living off sheer passion (or divine mission, in this case!). The sign and Spotify are subtle jabs: they suggest that today’s devs might need comfort and external stimuli to work, whereas yesterday’s devs just hunched over green-on-black terminals and powered through the night.

Importantly, the meme exaggerates for effect. Realistically, not all modern programmers are clueless about Vim or low-level concepts, and certainly old-school programmers used whatever help and comfort they could get, too. But the shared joke lands because there’s a kernel of truth: newer devs often start at a higher level of abstraction and have a wealth of answers available instantly, so they might not internalize certain fundamentals right away. Older devs had no choice but to learn those fundamentals thoroughly (or spend days stuck). This leads to that comedic scenario where a greybeard senior might whip up a custom script or fix a broken C library before lunch, while a junior next desk over is googling how to exit insert mode in Vim. It’s an “each generation solves different problems” situation.

In workplaces, this can manifest in humorous ways: seniors telling war stories about drilling through K&R C or writing assembly, while juniors share links to npm packages for everything. It’s essentially an inside joke among developers. The tags like TerminalHumor and LearningCurve are directly addressed here: Terminal humor because being stuck in the terminal (Vim) is a classic gag, and learning curve because it highlights how steep the curve can be when encountering older tools or low-level programming for the first time. And of course, the tag SeniorVsJuniorDevelopers is exactly what this meme is about. We’re laughing at the over-the-top contrast between a “senior” who’s depicted as having mythical abilities and a “junior” who’s depicted as needing hand-holding for the basics. Everyone knows it’s an exaggeration – but it’s funny because it taps into real feelings. Newcomers often feel imposter syndrome when they hear about legendary programmers or even just watch a veteran troubleshoot something in five minutes that would have taken them five hours. Veterans sometimes feel both pride and exasperation when they see newcomers reinventing the wheel or struggling with what they consider simple tasks. This meme takes that dynamic and cranks it to cartoonish extremes: building God a temple in code vs. crying for mommy about Vim.

Ultimately, the meme’s humor comes from our collective experience in tech and how it’s changed. It’s developer humor that both celebrates the insane skills of the past and pokes fun at the dependency culture of the present. After all, even the most hardcore old-timers today probably use Stack Overflow – and many modern coders eventually do go deep and learn those gnarly details. But for the sake of a good laugh, we imagine the scenario where the divide is absolute. And if anyone reading the meme doesn’t get why Cheems can’t exit Vim, well… they might just prove the meme right and have to look it up on Stack Overflow! (:wq not found?) 😅

Level 4: Bare-Metal Sorcery

At the most hardcore technical level, this meme contrasts a bygone era of bare-metal programming wizardry with today’s high-abstraction coding habits. On the left, the buff Doge programmer is essentially a one-person operating system architect. He’s casually talking about tweaking a HolyC compiler – implying he wrote his own compiler and perhaps an entire OS from scratch! This is a tongue-in-cheek reference to TempleOS, a real minimalist OS (with a fixed 640×480 VGA display) that one eccentric genius built single-handedly. Writing a compiler means designing everything from parsing source code into an AST (Abstract Syntax Tree) to generating machine code instructions. It’s serious computer science sorcery. The buff Doge isn’t just using technology; he’s creating it at the lowest level – controlling video mode, managing memory, handling hardware interrupts – the whole works. The meme has him say “Your third temple will be ready in a sec, in full 640x480”, hinting that he’s literally coding up a “Third Temple” for God in 16-color glory. That’s a nod to TempleOS’s biblical theme (its creator Terry Davis called it the Third Temple) and to old-school low-level programming where 640×480 graphics and direct memory manipulation were normal. Back in those days (and in TempleOS), drawing to the screen might mean poking pixel values into a VGA memory buffer at a fixed address. This buff Doge thrives in that world of pointers and bare metal control. Even the joke about “keeping the CIA busy” riffs on the legendary paranoia of TempleOS’s creator – but it also symbolizes how elite programmers of old might jibe that their code is so powerful or obscure that it confounds even top agencies. In short, the left panel represents an old-school systems programmer who operates with godlike confidence at the deepest layers of the machine.

Contrast that with the right panel’s modern Cheems developer, who is utterly removed from those low-level details. Cheems is struggling with something as fundamental as exiting Vim, a command-line text editor that’s been around since the 1970s. Not being able to exit Vim is a classic newbie predicament – it’s practically a rite of passage in learning the Unix/Linux command-line. On a deeper level, this highlights how far today’s developer environment is abstracted from the machine’s inner workings. Modern devs work in layers of high-level frameworks and user-friendly tools, so they rarely touch the raw OS or terminal unless necessary. When this Cheems accidentally drops into a raw CLI tool (like Vim) that doesn’t hold his hand, he’s completely lost. From a systems perspective, it’s ironic: Vim is just a text editor, trivial compared to writing a compiler, but it operates in a modal, keyboard-driven way that new devs haven’t internalized. The inability to perform this basic CLI task suggests a gap in fundamental knowledge – a far cry from the buff Doge who probably lives in Vim (or Emacs) and could exit it blindfolded.

The technological chasm here is huge. The buff Doge’s environment is a single-user, offline, self-built system – he likely is the OS kernel (TempleOS famously runs in ring-0, meaning no separation between user and kernel). He’s juggling registers, memory addresses, and writing code that directly interfaces with hardware. Meanwhile, Cheems’ environment is networked and convenience-driven: he has Spotify streaming music (modern computing power used for comfort), a decorative coffee quote sign, and constant access to the internet’s collective knowledge. If buff Doge represents monolithic mastery (one person controlling the full stack top to bottom), Cheems represents distributed dependency (relying on many external resources and tools). The meme’s extreme juxtaposition underscores how the laws of computing haven’t changed – bits and bytes are still underneath – but the typical programmer’s relationship to them sure has. Today’s coders stand on tall abstraction layers that make them productive but also blissfully ignorant of what’s under the hood. In a theoretical sense, the humor stems from the absurd imbalance in complexity: one side deals in compilers and OS development (complex algorithms, memory management, maybe even writing assembly) while the other side struggles with a user interface issue of a decades-old editor (a trivial problem if you know the trick). It’s like someone forgetting the Unix mantra “don’t exit Vim, Vim exits you…” (a sly joking reference to how Vim newbies feel). This contrast is only possible because modern computing has advanced to where one can be an effective developer without ever touching the “bare metal” – until an old-school tool like Vim suddenly forces you to. The result is a comedic reminder of the enormous shift in developer knowledge base and day-to-day skills over time.