Will AI take my DevOps job?
An honest view from inside: what AI can already do in my world of pipelines, servers and late-night alerts, what it can't, and how the job is changing.
An honest view from inside: what AI can already do in my world of pipelines, servers and late-night alerts, what it can't, and how the job is changing.
Ein ehrlicher Blick von innen: was KI in meiner Welt aus Pipelines, Servern und nächtlichen Alarmen schon kann, was nicht und wie sich der Job verändert.
ഉള്ളിൽ നിന്നുള്ള ഒരു സത്യസന്ധ കാഴ്ച: പൈപ്പ്ലൈനുകളുടെയും സെർവറുകളുടെയും രാത്രി അലേർട്ടുകളുടെയും എന്റെ ലോകത്ത് AI-ക്ക് ഇതിനകം എന്ത് ചെയ്യാം, എന്ത് ചെയ്യാൻ കഴിയില്ല, ജോലി എങ്ങനെ മാറുന്നു.
Every few weeks someone sends me a video with a title like "AI agent replaces entire DevOps team." I watch it, I laugh a little, and then, if I'm honest, I think about it a bit longer than I'd like to admit.
I'm a DevOps engineer. My job is to make sure software gets built, tested, shipped and kept running. Pipelines, cloud infrastructure, containers, monitoring, and the occasional alert that ruins a quiet evening. So when people say AI will automate everything, my job is supposed to be near the top of the list. Here's what I actually think.
Let's be fair first. AI has become genuinely useful in DevOps, and pretending otherwise would be silly.
Writing the boring configuration. A pipeline file, a Dockerfile, a Kubernetes manifest, a chunk of Terraform. Things that follow patterns and that I used to copy from old projects or documentation. An AI assistant gets me a solid first draft in seconds.
Reading logs faster than any human. When something breaks, the answer is usually buried in thousands of lines of logs. AI tools are very good at summarising them, spotting the one error that matters and pointing at the change that probably caused it.
Explaining unfamiliar things. An old script nobody remembers writing, a tool I haven't used before, a strange error message. Asking an AI to explain it saves a lot of searching.
Doing small fixes on its own. The newest tools act more like agents. They can see a failing test, read the logs, guess the cause, write a fix and open a pull request. The picture above isn't science fiction anymore.
And yet, the hard parts of my job are mostly not typing.
Knowing the context. Why is this service configured in this strange way? Because three years ago it caused an outage, and the fix was this exact strange setting. That knowledge lives in people's heads, old tickets and half-remembered conversations. AI sees the code. It doesn't see the history.
Taking responsibility. When production is down and customers are affected, someone has to decide: roll back, or push a fix forward? Wake up the database team, or wait ten minutes? Those calls involve risk, trade-offs and accountability. An AI can suggest. A human has to own it.
Being confidently wrong, safely. AI writes configuration that looks perfect and is subtly broken. A permission that's far too open. A setting that works in testing and falls over under real traffic. In infrastructure, small mistakes can be very expensive, or very public. Every AI suggestion still needs someone who can tell the difference.
Talking to people. A surprising amount of DevOps is conversation: understanding what developers need, agreeing on standards, explaining to a manager why we can't just "turn on the cloud and save money". No model does that for me.
AI is a very fast junior engineer who never gets tired, and never quite knows when it's wrong.
I don't think the job is disappearing. I think it's moving up a level.
Less time writing configuration by hand, more time reviewing it. Less time digging through logs, more time deciding what to do about what the logs say. Less time on repetitive fixes, more time designing systems that don't break in the first place. And a new kind of work: setting up the guardrails that let AI agents help safely. What they're allowed to touch, what needs a human approval, how we test their changes, how we undo them.
That last part is very DevOps. We've always been the people who build the safety rails for automation. AI is just a new, very powerful kind of automation.
There's also a funny twist. Someone has to build, deploy and keep the AI systems themselves running. Models need pipelines, monitoring, versioning, rollbacks and on-call too. That's a big part of why I started learning MLOps. If AI is coming into my world, I'd rather understand how it works from the inside than watch it from the outside.
Learn the fundamentals properly, because they're what let you judge AI's output: networking, Linux, how the cloud actually works, security basics. Use AI tools every day and get good at them, the same way earlier generations learned scripting. And practise the human side: writing clearly, explaining trade-offs, staying calm when things break.
The engineers who struggle won't be the ones replaced by AI. They'll be the ones replaced by engineers who use AI well.
Parts of it, yes. The repetitive parts, the copy-and-paste parts, the "read ten thousand log lines" parts. Honestly, I won't miss them.
The job itself? I think it will look quite different in five years. But someone will still need to understand the whole system, make the hard calls, and be the one who says "no, don't deploy that." For now, that's still me.
My take: AI proposes, humans decide. My job is making sure it stays that way where it matters.
— Desly
Alle paar Wochen schickt mir jemand ein Video mit einem Titel wie „KI-Agent ersetzt komplettes DevOps-Team“. Ich schaue es mir an, lache ein bisschen und denke dann, ehrlich gesagt, länger darüber nach, als ich zugeben möchte.
Ich bin DevOps-Engineer. Mein Job ist es, dafür zu sorgen, dass Software gebaut, getestet, ausgeliefert und am Laufen gehalten wird. Pipelines, Cloud-Infrastruktur, Container, Monitoring und gelegentlich ein Alarm, der einen ruhigen Abend ruiniert. Wenn also alle sagen, KI werde alles automatisieren, soll mein Job ziemlich weit oben auf der Liste stehen. Hier ist, was ich wirklich denke.
Erst mal fair bleiben. KI ist im DevOps-Bereich wirklich nützlich geworden, und etwas anderes zu behaupten wäre albern.
Die langweilige Konfiguration schreiben. Eine Pipeline-Datei, ein Dockerfile, ein Kubernetes-Manifest, ein Stück Terraform. Dinge, die Mustern folgen und die ich früher aus alten Projekten oder der Doku kopiert habe. Ein KI-Assistent liefert mir in Sekunden einen soliden ersten Entwurf.
Logs schneller lesen als jeder Mensch. Wenn etwas kaputtgeht, ist die Antwort meist in Tausenden Logzeilen vergraben. KI-Tools sind sehr gut darin, sie zusammenzufassen, den einen wichtigen Fehler zu finden und auf die Änderung zu zeigen, die ihn wahrscheinlich verursacht hat.
Unbekanntes erklären. Ein altes Skript, an dessen Entstehung sich niemand erinnert, ein Tool, das ich noch nie benutzt habe, eine seltsame Fehlermeldung. Eine KI um eine Erklärung zu bitten, spart viel Suchen.
Kleine Fehler selbst beheben. Die neuesten Tools verhalten sich eher wie Agenten. Sie sehen einen fehlschlagenden Test, lesen die Logs, vermuten die Ursache, schreiben eine Korrektur und öffnen einen Pull Request. Das Bild oben ist keine Science-Fiction mehr.
Und doch: Die schwierigen Teile meines Jobs sind meistens kein Tippen.
Den Kontext kennen. Warum ist dieser Dienst so seltsam konfiguriert? Weil er vor drei Jahren einen Ausfall verursacht hat und die Lösung genau diese seltsame Einstellung war. Dieses Wissen steckt in Köpfen, alten Tickets und halb erinnerten Gesprächen. Die KI sieht den Code. Die Geschichte sieht sie nicht.
Verantwortung übernehmen. Wenn die Produktion ausfällt und Kunden betroffen sind, muss jemand entscheiden: zurückrollen oder einen Fix nach vorne ausrollen? Das Datenbank-Team wecken oder zehn Minuten warten? Diese Entscheidungen haben mit Risiko, Abwägungen und Verantwortung zu tun. Eine KI kann vorschlagen. Ein Mensch muss es verantworten.
Selbstbewusst falsch liegen, sicher. KI schreibt Konfiguration, die perfekt aussieht und subtil kaputt ist. Eine viel zu offene Berechtigung. Eine Einstellung, die im Test funktioniert und unter echter Last umfällt. In der Infrastruktur können kleine Fehler sehr teuer oder sehr öffentlich werden. Jeder KI-Vorschlag braucht immer noch jemanden, der den Unterschied erkennt.
Mit Menschen reden. Überraschend viel von DevOps ist Gespräch: verstehen, was Entwickler brauchen, sich auf Standards einigen, einem Manager erklären, warum man nicht einfach „die Cloud einschalten und Geld sparen“ kann. Das macht kein Modell für mich.
KI ist ein sehr schneller Junior-Engineer, der nie müde wird und nie so recht weiß, wann er falschliegt.
Ich glaube nicht, dass der Job verschwindet. Ich glaube, er rückt eine Ebene nach oben.
Weniger Zeit, Konfiguration von Hand zu schreiben, mehr Zeit, sie zu prüfen. Weniger Zeit, in Logs zu wühlen, mehr Zeit, zu entscheiden, was man mit dem anfängt, was die Logs sagen. Weniger Zeit für wiederkehrende Korrekturen, mehr Zeit, Systeme zu entwerfen, die gar nicht erst kaputtgehen. Und eine neue Art von Arbeit: die Leitplanken bauen, mit denen KI-Agenten sicher helfen können. Was sie anfassen dürfen, was eine menschliche Freigabe braucht, wie wir ihre Änderungen testen und wie wir sie rückgängig machen.
Dieser letzte Teil ist sehr DevOps. Wir waren schon immer die, die Sicherheitsgeländer für Automatisierung bauen. KI ist nur eine neue, sehr mächtige Art von Automatisierung.
Es gibt auch eine lustige Wendung. Jemand muss die KI-Systeme selbst bauen, ausrollen und am Laufen halten. Auch Modelle brauchen Pipelines, Monitoring, Versionierung, Rollbacks und Rufbereitschaft. Das ist ein großer Teil davon, warum ich angefangen habe, MLOps zu lernen. Wenn KI in meine Welt kommt, will ich lieber von innen verstehen, wie sie funktioniert, als von außen zuzuschauen.
Lern die Grundlagen richtig, denn sie sind es, mit denen du die Ergebnisse der KI beurteilen kannst: Netzwerke, Linux, wie die Cloud wirklich funktioniert, Sicherheitsgrundlagen. Nutze KI-Tools jeden Tag und werde gut darin, so wie frühere Generationen Scripting gelernt haben. Und übe die menschliche Seite: klar schreiben, Abwägungen erklären, ruhig bleiben, wenn etwas kaputtgeht.
Es werden nicht die Engineers Probleme haben, die von KI ersetzt werden. Sondern die, die von Engineers ersetzt werden, die KI gut nutzen.
Teile davon, ja. Die repetitiven Teile, die Copy-Paste-Teile, die „lies zehntausend Logzeilen“-Teile. Ehrlich gesagt werde ich sie nicht vermissen.
Der Job selbst? Ich glaube, er wird in fünf Jahren ziemlich anders aussehen. Aber jemand wird immer noch das ganze System verstehen, die schweren Entscheidungen treffen und derjenige sein müssen, der sagt: „Nein, das deployen wir nicht.“ Im Moment bin das noch ich.
Mein Fazit: KI schlägt vor, Menschen entscheiden. Mein Job ist es, dafür zu sorgen, dass das dort so bleibt, wo es zählt.
— Desly
ഏതാനും ആഴ്ചകൾ കൂടുമ്പോൾ ആരെങ്കിലും എനിക്ക് "AI ഏജന്റ് ഒരു DevOps ടീമിനെ മുഴുവൻ മാറ്റിസ്ഥാപിക്കുന്നു" എന്നപോലുള്ള തലക്കെട്ടുള്ള ഒരു വീഡിയോ അയയ്ക്കും. ഞാൻ അത് കാണും, അൽപ്പം ചിരിക്കും, പിന്നെ, സത്യം പറഞ്ഞാൽ, സമ്മതിക്കാൻ ആഗ്രഹിക്കുന്നതിനേക്കാൾ കുറച്ചുനേരം കൂടി അതിനെക്കുറിച്ച് ചിന്തിക്കും.
ഞാൻ ഒരു DevOps എഞ്ചിനീയറാണ്. സോഫ്റ്റ്വെയർ നിർമ്മിക്കപ്പെടുകയും പരിശോധിക്കപ്പെടുകയും എത്തിക്കപ്പെടുകയും പ്രവർത്തിച്ചുകൊണ്ടിരിക്കുകയും ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുകയാണ് എന്റെ ജോലി. പൈപ്പ്ലൈനുകൾ, ക്ലൗഡ് ഇൻഫ്രാസ്ട്രക്ചർ, കണ്ടെയ്നറുകൾ, മോണിറ്ററിംഗ്, പിന്നെ ഇടയ്ക്കിടെ ഒരു ശാന്തമായ സന്ധ്യയെ നശിപ്പിക്കുന്ന ഒരു അലേർട്ടും. അതുകൊണ്ട് AI എല്ലാം ഓട്ടോമേറ്റ് ചെയ്യുമെന്ന് ആളുകൾ പറയുമ്പോൾ, എന്റെ ജോലി ലിസ്റ്റിന്റെ മുകളിലാണെന്നാണ് കരുതപ്പെടുന്നത്. ഞാൻ ശരിക്കും എന്ത് കരുതുന്നു എന്നത് ഇതാ.
ആദ്യം ന്യായമായി പറയാം. DevOps-ൽ AI ശരിക്കും ഉപകാരപ്രദമായിക്കഴിഞ്ഞു, അങ്ങനെയല്ലെന്ന് നടിക്കുന്നത് മണ്ടത്തരമാണ്.
വിരസമായ കോൺഫിഗറേഷൻ എഴുതൽ. ഒരു പൈപ്പ്ലൈൻ ഫയൽ, ഒരു Dockerfile, ഒരു Kubernetes മാനിഫെസ്റ്റ്, ഒരു കഷണം Terraform. പാറ്റേണുകൾ പിന്തുടരുന്ന, ഞാൻ പഴയ പ്രോജക്റ്റുകളിൽ നിന്നോ ഡോക്യുമെന്റേഷനിൽ നിന്നോ പകർത്തിയിരുന്ന കാര്യങ്ങൾ. ഒരു AI അസിസ്റ്റന്റ് നിമിഷങ്ങൾക്കുള്ളിൽ ഉറച്ച ഒരു ആദ്യ ഡ്രാഫ്റ്റ് തരുന്നു.
ഏതൊരു മനുഷ്യനേക്കാളും വേഗത്തിൽ ലോഗുകൾ വായിക്കൽ. എന്തെങ്കിലും തകരുമ്പോൾ, ഉത്തരം സാധാരണയായി ആയിരക്കണക്കിന് വരി ലോഗുകളിൽ കുഴിച്ചിട്ടിരിക്കും. AI ടൂളുകൾ അവ സംഗ്രഹിക്കുന്നതിലും, പ്രധാനപ്പെട്ട ആ ഒരു പിശക് കണ്ടെത്തുന്നതിലും, അതിന് കാരണമായിരിക്കാവുന്ന മാറ്റം ചൂണ്ടിക്കാണിക്കുന്നതിലും വളരെ മിടുക്കരാണ്.
അപരിചിതമായ കാര്യങ്ങൾ വിശദീകരിക്കൽ. എഴുതിയത് ആരും ഓർക്കാത്ത ഒരു പഴയ സ്ക്രിപ്റ്റ്, ഞാൻ മുമ്പ് ഉപയോഗിച്ചിട്ടില്ലാത്ത ഒരു ടൂൾ, ഒരു വിചിത്രമായ എറർ മെസേജ്. അത് വിശദീകരിക്കാൻ AI-യോട് ചോദിക്കുന്നത് ഒരുപാട് തിരച്ചിൽ ലാഭിക്കുന്നു.
ചെറിയ പരിഹാരങ്ങൾ സ്വയം ചെയ്യൽ. ഏറ്റവും പുതിയ ടൂളുകൾ ഏജന്റുകളെപ്പോലെയാണ് പ്രവർത്തിക്കുന്നത്. പരാജയപ്പെടുന്ന ഒരു ടെസ്റ്റ് കാണാനും, ലോഗുകൾ വായിക്കാനും, കാരണം ഊഹിക്കാനും, ഒരു പരിഹാരം എഴുതാനും, ഒരു പുൾ റിക്വസ്റ്റ് തുറക്കാനും അവയ്ക്ക് കഴിയും. മുകളിലെ ചിത്രം ഇനി സയൻസ് ഫിക്ഷനല്ല.
എന്നിട്ടും, എന്റെ ജോലിയിലെ കഠിനമായ ഭാഗങ്ങൾ മിക്കതും ടൈപ്പിംഗ് അല്ല.
സന്ദർഭം അറിയൽ. ഈ സർവീസ് എന്തുകൊണ്ട് ഈ വിചിത്രമായ രീതിയിൽ കോൺഫിഗർ ചെയ്തിരിക്കുന്നു? കാരണം മൂന്ന് വർഷം മുമ്പ് അത് ഒരു ഔട്ടേജിന് കാരണമായി, പരിഹാരം കൃത്യം ഈ വിചിത്രമായ സെറ്റിംഗായിരുന്നു. ആ അറിവ് ആളുകളുടെ തലയിലും പഴയ ടിക്കറ്റുകളിലും പാതി ഓർമ്മയുള്ള സംഭാഷണങ്ങളിലുമാണ്. AI കോഡ് കാണുന്നു. ചരിത്രം കാണുന്നില്ല.
ഉത്തരവാദിത്തം ഏറ്റെടുക്കൽ. പ്രൊഡക്ഷൻ ഡൗണാകുകയും ഉപഭോക്താക്കളെ ബാധിക്കുകയും ചെയ്യുമ്പോൾ, ആരെങ്കിലും തീരുമാനിക്കണം: റോൾബാക്ക് ചെയ്യണോ, അതോ ഒരു പരിഹാരം മുന്നോട്ട് പുഷ് ചെയ്യണോ? ഡാറ്റാബേസ് ടീമിനെ ഉണർത്തണോ, അതോ പത്ത് മിനിറ്റ് കാത്തിരിക്കണോ? ആ തീരുമാനങ്ങളിൽ റിസ്ക്, വിട്ടുവീഴ്ചകൾ, ഉത്തരവാദിത്തം എന്നിവയുണ്ട്. AI-ക്ക് നിർദ്ദേശിക്കാം. ഒരു മനുഷ്യൻ അത് ഏറ്റെടുക്കണം.
ആത്മവിശ്വാസത്തോടെ തെറ്റുന്നത്, സുരക്ഷിതമായി. AI പൂർണ്ണമെന്ന് തോന്നുന്ന, എന്നാൽ സൂക്ഷ്മമായി തകരാറുള്ള കോൺഫിഗറേഷൻ എഴുതും. വളരെയധികം തുറന്ന ഒരു പെർമിഷൻ. ടെസ്റ്റിംഗിൽ പ്രവർത്തിക്കുകയും യഥാർത്ഥ ട്രാഫിക്കിൽ വീഴുകയും ചെയ്യുന്ന ഒരു സെറ്റിംഗ്. ഇൻഫ്രാസ്ട്രക്ചറിൽ, ചെറിയ തെറ്റുകൾ വളരെ ചെലവേറിയതോ വളരെ പരസ്യമായതോ ആകാം. ഓരോ AI നിർദ്ദേശത്തിനും ഇപ്പോഴും വ്യത്യാസം തിരിച്ചറിയാൻ കഴിയുന്ന ഒരാൾ വേണം.
ആളുകളോട് സംസാരിക്കൽ. DevOps-ന്റെ അത്ഭുതകരമായ ഒരു ഭാഗം സംഭാഷണമാണ്: ഡെവലപ്പർമാർക്ക് എന്ത് വേണമെന്ന് മനസ്സിലാക്കൽ, സ്റ്റാൻഡേർഡുകളിൽ യോജിക്കൽ, "ക്ലൗഡ് ഓണാക്കി പണം ലാഭിക്കാൻ" എന്തുകൊണ്ട് കഴിയില്ലെന്ന് ഒരു മാനേജരോട് വിശദീകരിക്കൽ. ഒരു മോഡലും അത് എനിക്കുവേണ്ടി ചെയ്യില്ല.
ഒരിക്കലും ക്ഷീണിക്കാത്ത, എന്നാൽ തനിക്ക് തെറ്റുന്നത് എപ്പോഴാണെന്ന് ഒരിക്കലും കൃത്യമായി അറിയാത്ത, വളരെ വേഗതയുള്ള ഒരു ജൂനിയർ എഞ്ചിനീയറാണ് AI.
ജോലി അപ്രത്യക്ഷമാകുകയാണെന്ന് ഞാൻ കരുതുന്നില്ല. അത് ഒരു ലെവൽ മുകളിലേക്ക് നീങ്ങുകയാണെന്ന് ഞാൻ കരുതുന്നു.
കൈകൊണ്ട് കോൺഫിഗറേഷൻ എഴുതാൻ കുറച്ച് സമയം, അത് റിവ്യൂ ചെയ്യാൻ കൂടുതൽ സമയം. ലോഗുകളിലൂടെ കുഴിക്കാൻ കുറച്ച് സമയം, ലോഗുകൾ പറയുന്നതിനെക്കുറിച്ച് എന്ത് ചെയ്യണമെന്ന് തീരുമാനിക്കാൻ കൂടുതൽ സമയം. ആവർത്തിക്കുന്ന പരിഹാരങ്ങൾക്ക് കുറച്ച് സമയം, ആദ്യം തന്നെ തകരാത്ത സിസ്റ്റങ്ങൾ രൂപകൽപ്പന ചെയ്യാൻ കൂടുതൽ സമയം. പിന്നെ ഒരു പുതിയ തരം ജോലി: AI ഏജന്റുകളെ സുരക്ഷിതമായി സഹായിക്കാൻ അനുവദിക്കുന്ന ഗാർഡ്റെയിലുകൾ സജ്ജമാക്കൽ. അവയ്ക്ക് എന്ത് തൊടാം, എന്തിന് മനുഷ്യ അംഗീകാരം വേണം, അവയുടെ മാറ്റങ്ങൾ എങ്ങനെ പരിശോധിക്കാം, എങ്ങനെ പിൻവലിക്കാം.
ആ അവസാന ഭാഗം വളരെ DevOps ആണ്. ഓട്ടോമേഷനുള്ള സുരക്ഷാ റെയിലുകൾ നിർമ്മിക്കുന്നവരായിരുന്നു നമ്മൾ എന്നും. AI വളരെ ശക്തമായ ഒരു പുതിയ തരം ഓട്ടോമേഷൻ മാത്രമാണ്.
രസകരമായ ഒരു ട്വിസ്റ്റുമുണ്ട്. AI സിസ്റ്റങ്ങളെ തന്നെ നിർമ്മിക്കാനും വിന്യസിക്കാനും പ്രവർത്തിപ്പിച്ചുനിർത്താനും ആരെങ്കിലും വേണം. മോഡലുകൾക്കും പൈപ്പ്ലൈനുകൾ, മോണിറ്ററിംഗ്, വേർഷനിംഗ്, റോൾബാക്കുകൾ, ഓൺ-കോൾ എന്നിവ വേണം. ഞാൻ MLOps പഠിക്കാൻ തുടങ്ങിയതിന്റെ വലിയൊരു കാരണം അതാണ്. AI എന്റെ ലോകത്തേക്ക് വരുന്നുണ്ടെങ്കിൽ, പുറത്തുനിന്ന് നോക്കിനിൽക്കുന്നതിനേക്കാൾ, അത് ഉള്ളിൽ നിന്ന് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് മനസ്സിലാക്കാനാണ് എനിക്കിഷ്ടം.
അടിസ്ഥാനങ്ങൾ ശരിയായി പഠിക്കുക, കാരണം AI-യുടെ ഔട്ട്പുട്ട് വിലയിരുത്താൻ നിങ്ങളെ സഹായിക്കുന്നത് അവയാണ്: നെറ്റ്വർക്കിംഗ്, Linux, ക്ലൗഡ് ശരിക്കും എങ്ങനെ പ്രവർത്തിക്കുന്നു, സുരക്ഷയുടെ അടിസ്ഥാനങ്ങൾ. എല്ലാ ദിവസവും AI ടൂളുകൾ ഉപയോഗിക്കുക, മുൻ തലമുറകൾ സ്ക്രിപ്റ്റിംഗ് പഠിച്ചതുപോലെ അവയിൽ മിടുക്കരാകുക. മനുഷ്യവശവും പരിശീലിക്കുക: വ്യക്തമായി എഴുതുക, വിട്ടുവീഴ്ചകൾ വിശദീകരിക്കുക, കാര്യങ്ങൾ തകരുമ്പോൾ ശാന്തരായിരിക്കുക.
ബുദ്ധിമുട്ടുന്ന എഞ്ചിനീയർമാർ AI മാറ്റിസ്ഥാപിക്കുന്നവരായിരിക്കില്ല. AI നന്നായി ഉപയോഗിക്കുന്ന എഞ്ചിനീയർമാർ മാറ്റിസ്ഥാപിക്കുന്നവരായിരിക്കും.
അതിന്റെ ഭാഗങ്ങൾ, അതെ. ആവർത്തിക്കുന്ന ഭാഗങ്ങൾ, കോപ്പി-പേസ്റ്റ് ഭാഗങ്ങൾ, "പതിനായിരം ലോഗ് വരികൾ വായിക്കുക" ഭാഗങ്ങൾ. സത്യം പറഞ്ഞാൽ, എനിക്ക് അവ മിസ്സ് ചെയ്യില്ല.
ജോലി തന്നെ? അഞ്ച് വർഷത്തിനുള്ളിൽ അത് വളരെ വ്യത്യസ്തമായി കാണപ്പെടുമെന്ന് ഞാൻ കരുതുന്നു. പക്ഷേ മുഴുവൻ സിസ്റ്റവും മനസ്സിലാക്കാനും, കഠിനമായ തീരുമാനങ്ങൾ എടുക്കാനും, "വേണ്ട, അത് ഡിപ്ലോയ് ചെയ്യരുത്" എന്ന് പറയാനും ഇപ്പോഴും ആരെങ്കിലും വേണം. ഇപ്പോൾ, അത് ഇപ്പോഴും ഞാനാണ്.
എന്റെ അഭിപ്രായം: AI നിർദ്ദേശിക്കുന്നു, മനുഷ്യർ തീരുമാനിക്കുന്നു. പ്രധാനമായിടത്ത് അത് അങ്ങനെ തന്നെ തുടരുന്നുവെന്ന് ഉറപ്പാക്കലാണ് എന്റെ ജോലി.
— ഡെസ്ലി