LLM์ 'ํ๊ฐ'์ด ๊ฒฐํจ์ด ์๋๋ผ๊ณ ?
Is LLM's 'Hallucination' Not a Flaw?
์ธ๊ณ์ ์ธ ์ํํธ์จ์ด ๊ฐ๋ฐ ์ฌ์๊ฐ ๋งํด ํ์ธ๋ฌ๊ฐ ์ ์ํ๋ LLM ์๋์ ๊ฐ๋ฐ ํจ๋ฌ๋ค์! ๊ทธ์ ๋ ์นด๋ก์ด ํต์ฐฐ์ ํตํด '๋น๊ฒฐ์ ์ฑ'๊ณผ ์๋ก์ด ๋ณด์ ์ํ ๋ฑ ๊ฐ๋ฐ์๊ฐ ๋ง์ฃผํ ๋ฏธ๋๋ฅผ ๋ฏธ๋ฆฌ ํ์ธํด ๋ณด์ธ์.
The development paradigm for the LLM era presented by world-renowned software development thinker Martin Fowler! Get a preview of the future developers will face, including 'non-determinism' and new security threats, through his sharp insights.
์๋
ํ์ธ์! ์์ฆ ๋๋ ํ ๊ฒ ์์ด AI, ํนํ LLM(๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ)์ ์
๋ฌด์ ํ์ฉํ๊ณ ์์ฃ . ์ฝ๋๋ฅผ ์ง๊ฒ ํ๊ฑฐ๋, ์์ด๋์ด๋ฅผ ์ป๊ฑฐ๋, ์ฌ์ง์ด๋ ๋ณต์กํ ๊ฐ๋
์ ์ค๋ช
ํด๋ฌ๋ผ๊ณ ํ๊ธฐ๋ ํ๊ณ ์. ์ ์ญ์ LLM์ ํธ๋ฆฌํจ์ ํน ๋น ์ ธ ์ง๋ด๊ณ ์๋๋ฐ์, ๋ฌธ๋ ์ด๋ฐ ์๊ฐ์ด ๋ค๋๋ผ๊ณ ์. '๊ณผ์ฐ ์ฐ๋ฆฌ๋ ์ด ๋๊ตฌ๋ฅผ ์ ๋๋ก ์ดํดํ๊ณ ์ฌ์ฉํ๊ณ ์๋ ๊ฑธ๊น?'
Hello! Nowadays, everyone is using AI, especially LLMs (Large Language Models), for work. We make them write code, get ideas, or even ask them to explain complex concepts. I'm also deeply immersed in the convenience of LLMs, but a thought suddenly struck me: 'Are we truly understanding and using this tool correctly?'
์ด๋ฐ ๊ณ ๋ฏผ์ ์์ค์ ์ํํธ์จ์ด ๊ฐ๋ฐ ๋ถ์ผ์ ์ธ๊ณ์ ์ธ ๊ตฌ๋ฃจ, ๋งํด ํ์ธ๋ฌ(Martin Fowler)๊ฐ ์ต๊ทผ LLM๊ณผ ์ํํธ์จ์ด ๊ฐ๋ฐ์ ๋ํ ์๊ฐ์ ์ ๋ฆฌํ ๊ธ์ ์ฝ๊ฒ ๋์์ต๋๋ค. ๋จ์ํ 'LLM์ ๋๋จํด!' ์์ค์ ๋์ด, ๊ทธ ๋ณธ์ง์ ์ธ ํน์ฑ๊ณผ ์ฐ๋ฆฌ๊ฐ ์์ผ๋ก ๋ง์ฃผํ๊ฒ ๋ ๋ณํ์ ๋ํ ๊น์ด ์๋ ํต์ฐฐ์ด ๋ด๊ฒจ ์์์ฃ . ์ค๋์ ์ฌ๋ฌ๋ถ๊ณผ ํจ๊ป ๊ทธ์ ์๊ฐ์ ๋ฐ๋ผ๊ฐ ๋ณด๋ ค๊ณ ํฉ๋๋ค. ๐
While pondering this, I came across an article by Martin Fowler, a world-renowned guru in the software development field, who recently summarized his thoughts on LLMs and software development. It went beyond a simple 'LLMs are amazing!' level, offering deep insights into their fundamental nature and the changes we will face. Today, I'd like to explore his thoughts with you. ๐
LLM and Software Development
๋งํด ํ์ธ๋ฌ, LLM์ ํ์ฃผ์๋ฅผ ๋งํ๋ค ๐ค
Martin Fowler on the Current State of LLMs ๐ค
๋งํด ํ์ธ๋ฌ๋ ๋จผ์ ํ์ฌ AI ์ฐ์
์ด ๋ช
๋ฐฑํ '๋ฒ๋ธ' ์ํ์ ์๋ค๊ณ ์ง๋จํฉ๋๋ค. ํ์ง๋ง ์ญ์ฌ์ ์ผ๋ก ๋ชจ๋ ๊ธฐ์ ํ์ ์ด ๊ทธ๋์๋ฏ, ๋ฒ๋ธ์ด ๊บผ์ง ํ์๋ ์๋ง์กด์ฒ๋ผ ์ด์๋จ์ ์๋ก์ด ์๋๋ฅผ ์ฌ๋ ๊ธฐ์
์ด ๋ํ๋ ๊ฒ์ด๋ผ๊ณ ๋ดค์ด์. ์ค์ํ ๊ฑด, ์ง๊ธ ๋จ๊ณ์์๋ ํ๋ก๊ทธ๋๋ฐ์ ๋ฏธ๋๋ ํน์ ์ง์
์ ์์ ์ฑ์ ๋ํด ๋๊ตฌ๋ ํ์คํ ์ ์ ์๋ค๋ ์ ์
๋๋ค.
Martin Fowler first diagnoses the current AI industry as being in a clear 'bubble' state. However, as with all technological innovations historically, he believes that even after the bubble bursts, companies like Amazon will survive and usher in a new era. The important thing is that at this stage, no one can be certain about the future of programming or the job security of specific professions.
๊ทธ๋์ ๊ทธ๋ ์ฃ๋ถ๋ฅธ ์์ธก๋ณด๋ค๋ ๊ฐ์ LLM์ ์ง์ ์ฌ์ฉํด๋ณด๊ณ , ๊ทธ ๊ฒฝํ์ ์ ๊ทน์ ์ผ๋ก ๊ณต์ ํ๋ ์คํ์ ์ธ ์์ธ๊ฐ ์ค์ํ๋ค๊ณ ๊ฐ์กฐํฉ๋๋ค. ์ฐ๋ฆฌ ๋ชจ๋๊ฐ ์๋ก์ด ๋๊ตฌ๋ฅผ ํํํ๋ ๊ฐ์ฒ์๊ฐ ๋์ด์ผ ํ๋ค๋ ์๋ฏธ๊ฒ ์ฃ ?
Therefore, he emphasizes that an experimental attitude of personally using LLMs and actively sharing those experiences is more important than making hasty predictions. This implies that we all need to become pioneers exploring this new tool, right?
๐ก ์์๋์ธ์!
๐ก Good to know!
ํ์ธ๋ฌ๋ ์ต๊ทผ LLM ํ์ฉ์ ๋ํ ์ค๋ฌธ์กฐ์ฌ๋ค์ด ์ค์ ์ฌ์ฉ ํ๋ฆ์ ์ ๋๋ก ๋ฐ์ํ์ง ๋ชปํ ์ ์๋ค๊ณ ์ง์ ํ์ด์. ๋ค์ํ ๋ชจ๋ธ์ ๊ธฐ๋ฅ ์ฐจ์ด๋ ํฌ๊ธฐ ๋๋ฌธ์, ๋ค๋ฅธ ์ฌ๋์ ์๊ฒฌ๋ณด๋ค๋ ์์ ์ ์ง์ ์ ์ธ ๊ฒฝํ์ ๋ฏฟ๋ ๊ฒ์ด ๋ ์ค์ํด ๋ณด์
๋๋ค.
Fowler pointed out that recent surveys on LLM usage may not accurately reflect actual usage patterns. Since there are also significant differences in the capabilities of various models, it seems more important to trust your own direct experience rather than the opinions of others.
LLM์ ํ๊ฐ: ๊ฒฐํจ์ด ์๋ ๋ณธ์ง์ ํน์ง ๐ง
LLM Hallucination: An Intrinsic Feature, Not a Flaw ๐ง
์ด๋ฒ ๊ธ์์ ๊ฐ์ฅ ํฅ๋ฏธ๋ก์ ๋ ๋ถ๋ถ์
๋๋ค. ํ์ธ๋ฌ๋ LLM์ด ์ฌ์ค์ด ์๋ ์ ๋ณด๋ฅผ ๊ทธ๋ด๋ฏํ๊ฒ ๋ง๋ค์ด๋ด๋ 'ํ๊ฐ(Hallucination)' ํ์์ ๋จ์ํ '๊ฒฐํจ'์ด ์๋๋ผ '๋ณธ์ง์ ์ธ ํน์ฑ'์ผ๋ก ๋ด์ผ ํ๋ค๊ณ ์ฃผ์ฅํฉ๋๋ค. ์ ๋ง ์ถฉ๊ฒฉ์ ์ด์ง ์๋์? LLM์ ๊ฒฐ๊ตญ '์ ์ฉ์ฑ์ด ์๋ ํ๊ฐ์ ์์ฑํ๊ธฐ ์ํ ๋๊ตฌ'๋ผ๋ ๊ด์ ์
๋๋ค.
This was the most interesting part of the article for me. Fowler argues that the 'hallucination' phenomenon, where LLMs create plausible but untrue information, should be seen as an 'intrinsic feature' rather than a mere 'flaw'. Isn't that shocking? The perspective is that LLMs are ultimately 'tools for generating useful hallucinations'.
์ด๋ฐ ๊ด์ ์์ ๋ณด๋ฉด, ์ฐ๋ฆฌ๋ LLM์ ๋ต๋ณ์ ๋งน๋ชฉ์ ์ผ๋ก ์ ๋ขฐํด์๋ ์ ๋ฉ๋๋ค. ์คํ๋ ค ๋์ผํ ์ง๋ฌธ์ ์ฌ๋ฌ ๋ฒ, ํํ์ ๋ฐ๊ฟ๊ฐ๋ฉฐ ๋์ ธ๋ณด๊ณ ๋ต๋ณ์ ์ผ๊ด์ฑ์ ํ์ธํ๋ ์์
์ด ํ์์ ์
๋๋ค. ํนํ ์ซ์ ๊ณ์ฐ๊ณผ ๊ฐ์ด ๊ฒฐ์ ์ ์ธ ๋ต์ด ํ์ํ ๋ฌธ์ ์ LLM์ ์ง์ ์ฌ์ฉํ๋ ค๋ ์๋๋ ์ ์ ํ์ง ์๋ค๊ณ ๋ง๋ถ์์ต๋๋ค.
From this viewpoint, we should not blindly trust the answers from LLMs. Instead, it is essential to ask the same question multiple times with different phrasing to check for consistency in the answers. He added that attempting to use LLMs directly for problems requiring definitive answers, such as numerical calculations, is not appropriate.
⚠️ ์ฃผ์ํ์ธ์!
⚠️ Be careful!
ํ์ธ๋ฌ๋ LLM์ '์ฃผ๋์ด ๊ฐ๋ฐ์'์ ๋น์ ํ๋ ๊ฒ์ ๊ฐํ๊ฒ ๋นํํฉ๋๋ค. LLM์ "๋ชจ๋ ํ
์คํธ ํต๊ณผ!"๋ผ๊ณ ์์ ์๊ฒ ๋งํ๋ฉด์ ์ค์ ๋ก๋ ํ
์คํธ๋ฅผ ์คํจ์ํค๋ ์ฝ๋๋ฅผ ๋ด๋๋ ๊ฒฝ์ฐ๊ฐ ํํ์ฃ . ๋ง์ฝ ์ธ๊ฐ ๋๋ฃ๊ฐ ์ด๋ฐ ํ๋์ ๋ฐ๋ณตํ๋ค๋ฉด, ์ ๋ขฐ๋ฅผ ์๊ณ ์ธ์ฌ ๋ฌธ์ ๋ก ์ด์ด์ง ์์ค์ ์ฌ๊ฐํ ๊ฒฐํจ์ด๋ผ๋ ๊ฒ์
๋๋ค. LLM์ ๋๋ฃ๊ฐ ์๋, ๊ฐ๋ ฅํ์ง๋ง ์ค์๋ฅผ ์ ์ง๋ฅผ ์ ์๋ '๋๊ตฌ'๋ก ์ธ์ํด์ผ ํฉ๋๋ค.
Fowler strongly criticizes the analogy of an LLM to a 'junior developer'. LLMs often confidently state "All tests passed!" while providing code that actually fails tests. If a human colleague were to do this repeatedly, it would be a serious flaw leading to a loss of trust and personnel issues. LLMs should be recognized not as colleagues, but as powerful 'tools' that can make mistakes.
์ํํธ์จ์ด ๊ณตํ, '๋น๊ฒฐ์ ์ฑ' ์๋๋ก์ ์ ํ ๐ฒ
Software Engineering's Shift to an Era of 'Non-Determinism' ๐ฒ
์ ํต์ ์ธ ์ํํธ์จ์ด ๊ณตํ์ '๊ฒฐ์ ๋ก ์ '์ธ ์ธ๊ณ ์์ ์ธ์์ ธ ์์์ต๋๋ค. '2+2'๋ฅผ ์
๋ ฅํ๋ฉด '4'๊ฐ ๋์์ผ ํ๋ฏ, ๋ชจ๋ ๊ฒ์ ์์ธก ๊ฐ๋ฅํ๊ณ ์ผ๊ด์ ์ด์ด์ผ ํ์ฃ . ์์๊ณผ ๋ค๋ฅธ ๊ฒฐ๊ณผ๋ '๋ฒ๊ทธ'๋ก ์ทจ๊ธ๋์ด ์ฆ์ ์์ ๋์์ต๋๋ค.
Traditional software engineering was built on a 'deterministic' world. Just as inputting '2+2' must yield '4', everything had to be predictable and consistent. Unexpected results were treated as 'bugs' and fixed immediately.
ํ์ง๋ง LLM์ ๋ฑ์ฅ์ ์ด๋ฌํ ํจ๋ฌ๋ค์์ ๊ทผ๋ณธ์ ์ผ๋ก ๋ฐ๊พธ๊ณ ์์ต๋๋ค. ํ์ธ๋ฌ๋ LLM์ด ์ํํธ์จ์ด ๊ณตํ์ '๋น๊ฒฐ์ ์ฑ(Non-Determinism)'์ ๋์
ํ๋ ์ ํ์ ์ด ๋ ๊ฒ์ด๋ผ๊ณ ์ง๋จํฉ๋๋ค. ๋์ผํ ์์ฒญ์๋ LLM์ ๋ฏธ๋ฌํ๊ฒ ๋ค๋ฅธ ๊ฒฐ๊ณผ๋ฌผ์ ๋ด๋์ ์ ์์ผ๋ฉฐ, ๊ทธ๋ด๋ฏํด ๋ณด์ด๋ ์ฝ๋ ์์ ์น๋ช
์ ์ธ ์ค๋ฅ๋ฅผ ์จ๊ฒจ๋๊ธฐ๋ ํฉ๋๋ค.
However, the emergence of LLMs is fundamentally changing this paradigm. Fowler diagnoses that LLMs will be a turning point, introducing 'Non-Determinism' into software engineering. Even with the same request, an LLM can produce subtly different outputs and may hide critical errors within plausible-looking code.
์ด์ ๊ฐ๋ฐ์์ ์ญํ ์ ๋จ์ํ ์ฝ๋๋ฅผ ์์ฑํ๋ ๊ฒ์ ๋์ด, LLM์ด ๋ง๋ค์ด๋ธ ๋ถํ์คํ ๊ฒฐ๊ณผ๋ฌผ์ ๋นํ์ ์ผ๋ก ๊ฒ์ฆํ๊ณ ๊ด๋ฆฌํ๋ ๋ฅ๋ ฅ์ด ๋์ฑ ์ค์ํด์ก์ต๋๋ค. ์๋ ํ๋ก ๊ทธ ์ฐจ์ด๋ฅผ ๊ฐ๋จํ ์ ๋ฆฌํด๋ดค์ต๋๋ค.
Now, the role of a developer has become more about the ability to critically verify and manage the uncertain outputs generated by LLMs, going beyond simply writing code. I've summarized the differences in the table below.
๊ตฌ๋ถ Category |
์ ํต์ ์ํํธ์จ์ด (๊ฒฐ์ ์ ) Traditional Software (Deterministic) |
LLM ๊ธฐ๋ฐ ์ํํธ์จ์ด (๋น๊ฒฐ์ ์ ) LLM-based Software (Non-deterministic) |
๊ฒฐ๊ณผ ์์ธก์ฑ Result Predictability |
๋์ผ ์
๋ ฅ, ๋์ผ ๊ฒฐ๊ณผ ๋ณด์ฅ Same input, same output guaranteed |
๋์ผ ์
๋ ฅ์๋ ๋ค๋ฅธ ๊ฒฐ๊ณผ ๊ฐ๋ฅ Different outputs possible for the same input |
์ค๋ฅ์ ์ ์ Definition of Error |
์์ธก์ ๋ฒ์ด๋ ๋ชจ๋ ๋์ (๋ฒ๊ทธ) Any behavior deviating from prediction (Bug) |
๊ฒฐ๊ณผ์ ๋ถํ์ค์ฑ (๋ณธ์ง์ ํน์ฑ) Uncertainty of results (Intrinsic feature) |
๊ฐ๋ฐ์ ์ญํ Developer's Role |
์ ํํ ๋ก์ง ๊ตฌํ ๋ฐ ๋๋ฒ๊น
Implementing precise logic and debugging |
๊ฒฐ๊ณผ๋ฌผ ๊ฒ์ฆ ๋ฐ ๋ถํ์ค์ฑ ๊ด๋ฆฌ Verifying outputs and managing uncertainty |
ํผํ ์ ์๋ ์ํ: ๋ณด์ ๋ฌธ์ ๐
The Unavoidable Threat: Security Issues ๐
๋ง์ง๋ง์ผ๋ก ํ์ธ๋ฌ๋ LLM์ด ์ํํธ์จ์ด ์์คํ
์ ๊ณต๊ฒฉ ํ๋ฉด์ ๊ด๋ฒ์ํ๊ฒ ํ๋ํ๋ค๋ ์ฌ๊ฐํ ๊ฒฝ๊ณ ๋ฅผ ๋์ง๋๋ค. ํนํ ๋ธ๋ผ์ฐ์ ์์ด์ ํธ์ ๊ฐ์ด ๋น๊ณต๊ฐ ๋ฐ์ดํฐ ์ ๊ทผ, ์ธ๋ถ ํต์ , ์ ๋ขฐํ ์ ์๋ ์ฝํ
์ธ ๋
ธ์ถ์ด๋ผ๋ '์น๋ช
์ ์ผ์ค' ์ํ์ ๊ฐ์ง ๋๊ตฌ๋ค์ ๊ทผ๋ณธ์ ์ผ๋ก ์์ ํ๊ฒ ๋ง๋ค๊ธฐ ์ด๋ ต๋ค๋ ๊ฒ์ด ๊ทธ์ ์๊ฒฌ์
๋๋ค.
Finally, Fowler issues a serious warning that LLMs significantly expand the attack surface of software systems. He opines that tools with the 'lethal triple' risk of accessing private data, communicating externally, and being exposed to untrusted content, such as browser agents, are fundamentally difficult to secure.
์๋ฅผ ๋ค์ด, ์น ํ์ด์ง์ ์ธ๊ฐ์ ๋์๋ ๋ณด์ด์ง ์๋ ๋ช
๋ น์ด๋ฅผ ์จ๊ฒจ LLM์ ์์ด๊ณ , ์ด๋ฅผ ํตํด ๋ฏผ๊ฐํ ๊ฐ์ธ ์ ๋ณด๋ฅผ ์ ์ถํ๋๋ก ์ ๋ํ๋ ๊ณต๊ฒฉ์ด ๊ฐ๋ฅํด์ง๋๋ค. ๊ฐ๋ฐ์๋ค์ ์ด์ ์ฝ๋์ ๊ธฐ๋ฅ๋ฟ๋ง ์๋๋ผ, LLM๊ณผ ์ํธ์์ฉํ๋ ๋ชจ๋ ๊ณผ์ ์์ ๋ฐ์ํ ์ ์๋ ์๋ก์ด ๋ณด์ ์ทจ์ฝ์ ์ ๊ณ ๋ คํด์ผ ํฉ๋๋ค.
For example, it becomes possible to trick an LLM by hiding commands invisible to the human eye on a web page, thereby inducing it to leak sensitive personal information. Developers must now consider not only the functionality of their code but also new security vulnerabilities that can arise in all processes interacting with LLMs.
ํ๊ฐ์ ๋ณธ์ง:
Hallucination is Intrinsic: LLM์ ํ๊ฐ์ '๊ฒฐํจ'์ด ์๋ '๋ณธ์ง์ ํน์ง'์ผ๋ก ์ดํดํด์ผ ํฉ๋๋ค.
LLM's hallucination must be understood as an 'intrinsic feature,' not a 'flaw.'
๋น๊ฒฐ์ ์ฑ์ ์๋:
The Era of Non-Determinism: ์ํํธ์จ์ด ๊ณตํ์ด ์์ธก ๋ถ๊ฐ๋ฅ์ฑ์ ๊ด๋ฆฌํ๋ ์๋๋ก ์ง์
ํ์ต๋๋ค.
Software engineering has entered an era of managing unpredictability.
๊ฒ์ฆ์ ํ์:
Verification is a Must:
LLM์ ๊ฒฐ๊ณผ๋ฌผ์ ์ฃผ๋์ด ๊ฐ๋ฐ์๊ฐ ์๋, ๊ฒ์ฆ์ด ํ์์ ์ธ '๋๊ตฌ'์ ์ฐ์ถ๋ฌผ์
๋๋ค.
The output of an LLM is not that of a junior developer, but the product of a 'tool' that requires mandatory verification.
๋ณด์ ์ํ:
Security Threats: LLM์ ์์คํ
์ ๊ณต๊ฒฉ ํ๋ฉด์ ๋ํ๋ ์๋ก์ด ๋ณด์ ๋ณ์์
๋๋ค.
LLMs are a new security variable that broadens a system's attack surface.
์์ฃผ ๋ฌป๋ ์ง๋ฌธ ❓
Frequently Asked Questions ❓
Q: ๋งํด ํ์ธ๋ฌ๊ฐ 'ํ๊ฐ'์ ๊ฒฐํจ์ด ์๋ ๋ณธ์ง๋ก ๋ด์ผ ํ๋ค๊ณ ๋งํ๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์?
Q: Why does Martin Fowler say that 'hallucination' should be seen as an intrinsic feature, not a flaw?
A: LLM์ ๋ฐฉ๋ํ ๋ฐ์ดํฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๊ฐ์ฅ ๊ทธ๋ด๋ฏํ ๋ค์ ๋จ์ด๋ฅผ ์์ธกํ์ฌ ๋ฌธ์ฅ์ ์์ฑํ๋ ๋ชจ๋ธ์ด๊ธฐ ๋๋ฌธ์
๋๋ค. ์ด ๊ณผ์ ์์ ์ฌ์ค๊ด๊ณ์ ๋ฌด๊ดํ๊ฒ ๋งค๋๋ฌ์ด ๋ฌธ์ฅ์ ๋ง๋ค์ด๋ด๋ 'ํ๊ฐ'์ ์์ฐ์ค๋ฌ์ด ๊ฒฐ๊ณผ๋ฌผ์ด๋ฉฐ, ์ด ํน์ฑ์ ์ดํดํด์ผ LLM์ ์ฌ๋ฐ๋ฅด๊ฒ ํ์ฉํ ์ ์๋ค๋ ์๋ฏธ์
๋๋ค.
A: This is because LLMs are models that generate sentences by predicting the most plausible next word based on vast amounts of data. In this process, 'hallucination,' which creates fluent sentences regardless of factual accuracy, is a natural outcome. Understanding this characteristic is key to using LLMs correctly.
Q: ์ํํธ์จ์ด ๊ณตํ์ '๋น๊ฒฐ์ ์ฑ'์ด๋ ๋ฌด์์ ์๋ฏธํ๋ฉฐ, ์ ์ค์ํ๊ฐ์?
Q: What does 'non-determinism' in software engineering mean, and why is it important?
A: '๋น๊ฒฐ์ ์ฑ'์ด๋ ๋์ผํ ์
๋ ฅ์ ๋ํด ํญ์ ๋์ผํ ๊ฒฐ๊ณผ๊ฐ ๋์ค์ง ์๋ ํน์ฑ์ ์๋ฏธํฉ๋๋ค. ์ ํต์ ์ธ ์ํํธ์จ์ด๋ 100% ์์ธก ๊ฐ๋ฅํด์ผ ํ์ง๋ง, LLM์ ๊ฐ์ ์ง๋ฌธ์๋ ๋ค๋ฅธ ๋ต๋ณ์ ์ค ์ ์์ต๋๋ค. ์ด ๋ถํ์ค์ฑ์ ์ดํดํ๊ณ ๊ด๋ฆฌํ๋ ๊ฒ์ด LLM ์๋ ๊ฐ๋ฐ์์ ํต์ฌ ์ญ๋์ด ๋์์ต๋๋ค.
A: 'Non-determinism' refers to the characteristic where the same input does not always produce the same output. While traditional software had to be 100% predictable, an LLM can give different answers to the same question. Understanding and managing this uncertainty has become a core competency for developers in the age of LLMs.
Q: LLM์ด ์์ฑํ ์ฝ๋๋ฅผ ์ ๋ขฐํ๊ณ ๋ฐ๋ก ์ฌ์ฉํด๋ ๋ ๊น์?
Q: Can I trust and use the code generated by an LLM immediately?
A: ์๋์, ์ ๋ ์ ๋ฉ๋๋ค. ๋งํด ํ์ธ๋ฌ๋ LLM์ด ๊ทธ๋ด๋ฏํ์ง๋ง ์๋ํ์ง ์๊ฑฐ๋, ๋ณด์์ ์ทจ์ฝํ ์ฝ๋๋ฅผ ์์ฑํ ์ ์๋ค๊ณ ๊ฒฝ๊ณ ํฉ๋๋ค. ์์ฑ๋ ์ฝ๋๋ ๋ฐ๋์ ๊ฐ๋ฐ์๊ฐ ์ง์ ๊ฒํ , ํ
์คํธ, ๊ฒ์ฆํ๋ ๊ณผ์ ์ ๊ฑฐ์ณ์ผ ํฉ๋๋ค.
A: No, absolutely not. Martin Fowler warns that LLMs can generate code that looks plausible but doesn't work or is insecure. The generated code must be reviewed, tested, and verified by a developer.
Q: LLM์ ์ฌ์ฉํ๋ฉด ์ ๋ณด์ ์ํ์ด ์ปค์ง๋์?
Q: Why do security threats increase with the use of LLMs?
A: LLM์ ์ธ๋ถ ๋ฐ์ดํฐ์ ์ํธ์์ฉํ๊ณ , ๋๋ก๋ ๋ฏผ๊ฐํ ์ ๋ณด์ ์ ๊ทผํ ์ ์๊ธฐ ๋๋ฌธ์
๋๋ค. ์
์์ ์ธ ์ฌ์ฉ์๊ฐ ์น์ฌ์ดํธ๋ ์
๋ ฅ๊ฐ์ ๋ณด์ด์ง ์๋ ๋ช
๋ น์ด๋ฅผ ์จ๊ฒจ LLM์ ์กฐ์ข
(ํ๋กฌํํธ ์ธ์ ์
)ํ์ฌ ์ ๋ณด๋ฅผ ์ ์ถํ๊ฑฐ๋ ์์คํ
์ ๊ณต๊ฒฉํ๋ ์๋ก์ด ํํ์ ๋ณด์ ์ํ์ด ๋ฐ์ํ ์ ์์ต๋๋ค.
A: Because LLMs interact with external data and can sometimes access sensitive information. Malicious users can hide invisible commands in websites or inputs to manipulate the LLM (prompt injection), leading to new types of security threats such as data leakage or system attacks.
๋งํด ํ์ธ๋ฌ์ ํต์ฐฐ์ LLM์ด๋ผ๋ ์๋ก์ด ๋๊ตฌ๋ฅผ ์ด๋ป๊ฒ ๋ฐ๋ผ๋ณด๊ณ ์ฌ์ฉํด์ผ ํ๋์ง์ ๋ํ ์ค์ํ ๊ฐ์ด๋๋ฅผ ์ ์ํฉ๋๋ค. ๋จ์ํ ํธ๋ฆฌํ ์ฝ๋ ์์ฑ๊ธฐ๋ฅผ ๋์ด, ์ฐ๋ฆฌ ๊ฐ๋ฐ ํ๊ฒฝ์ ๊ทผ๋ณธ์ ์ธ ํจ๋ฌ๋ค์์ ๋ฐ๊พธ๋ ์กด์ฌ์์ ์ธ์ํด์ผ ํฉ๋๋ค. ๊ทธ์ ์กฐ์ธ์ฒ๋ผ, ๋๋ ค์ํ๊ฑฐ๋ ๋งน์ ํ๊ธฐ๋ณด๋ค๋ ์ ๊ทน์ ์ผ๋ก ์คํํ๊ณ ๊ฒฝํ์ ๊ณต์ ํ๋ฉฐ ์ด ๊ฑฐ๋ํ ๋ณํ์ ๋ฌผ๊ฒฐ์ ํ๋ช
ํ๊ฒ ์ฌ๋ผํ์ผ ํ ๋์
๋๋ค.
Martin Fowler's insights provide an important guide on how to view and use the new tool that is the LLM. We must recognize it not just as a convenient code generator, but as an entity that is changing the fundamental paradigm of our development environment. As he advises, now is the time to wisely ride this massive wave of change by experimenting and sharing experiences, rather than fearing or blindly trusting it.
์ฌ๋ฌ๋ถ์ LLM์ ๋ํด ์ด๋ป๊ฒ ์๊ฐํ์๋์? ๊ฐ๋ฐ ๊ณผ์ ์์ ๊ฒช์๋ ํฅ๋ฏธ๋ก์ด ๊ฒฝํ์ด ์๋ค๋ฉด ๋๊ธ๋ก ๊ณต์ ํด์ฃผ์ธ์! ๐
What are your thoughts on LLMs? If you have any interesting experiences from your development process, please share them in the comments! ๐