the whole portfolio is, for now, very heavily made with ai. not just the code help, but also much of the writing. i fed it a lot of my own data, projects, folders, old repos, screenshots, notes, and context. so it is not random. but it is still true that i am not sitting here writing and coding every piece myself in the old way.
and the uncomfortable part is that i love it.
i love it because it removes so much of the work i hate.
setting up a server, fixing docker files, redeploying, checking logs, pushing commits, reading docs for some framework i barely know, scraping together boilerplate, opening ten tabs just to remember one syntax detail, fighting with a terminal over something boring. i hate how much time that kind of work can eat. sometimes it feels like the actual idea is small and clear, and then there is this huge swamp of implementation friction around it.
here, with ai helping directly inside the flow, a lot of that friction just disappears. i do not have to switch context as much. i do not have to spend half an hour remembering how one command or config detail works. i do not even have to do the stupid small rituals around coding if the actual intention is already clear.
that feels amazing.
but that is also where the doubt starts.
what if the hated part was also the learning part
one thought that keeps coming back is that maybe some of the work i hate was also the place where a lot of technical depth used to come from.
if i had built this portfolio without ai, i would probably have had to read Astro docs for a while, compare examples, scrape together some ugly solution, run into errors, fix them, misunderstand the content collection system once or twice, and slowly piece together how the whole thing actually works.
instead, i watched over it, understood a lot of it while it happened, looked through the files, adjusted things, changed wording, moved sections, corrected the direction, and got something real much faster.
that sounds good, and it is good.
but there is still a difference between:
- understanding something while it is shown to you
- and understanding something because you had to wrestle it into existence yourself
i can feel that difference very clearly.
i am not a beginner, but i am also not the person who can casually do everything
i have been coding for some years now, so it is not like i am completely new. i am not at zero. i would call myself intermediate at least. i can read code, i can understand systems, i can make changes, i can reason about structure, and i can usually tell when something generally makes sense.
but i also know i am nowhere near one of those people who can just sit down cold and build anything cleanly from memory.
if you gave me a framework i have not touched in a while, or infrastructure i only half remember, or a stack with too many moving parts, i would absolutely have to read docs, patch things together, make mistakes, and spend a lot of time on the boring parts before i got back to the interesting part.
that matters here, because AI is entering exactly at that level.
it is not just helping me after i already know everything. it is removing a lot of the middle layer that i would otherwise still have to grind through myself.
this is how seniors work, but what does it mean if i am not there yet
another thought i keep running into is that this whole setup feels a lot like how senior people work.
they do not necessarily code every line themselves. they do not manually fight through every tiny setup step. they delegate. they supervise. they review direction. they correct. they make decisions at a higher level.
and that is exactly what this can feel like with ai. i describe the intention, i check the shape of the result, i redirect, i reject the wrong tone, i refine, and the implementation keeps moving.
but then the question becomes: what is that worth if i did not fully earn the lower layer first?
if a senior delegates, it usually rests on a base of having done the ugly parts for years already. they know what they are skipping. they know what is fragile. they know where to mistrust the output. they know what kind of shortcut is harmless and what kind will come back later as technical debt or confusion.
that is the part i am unsure about.
because if i move too quickly into the supervisory layer without enough depth underneath, then maybe i am not really operating like a senior. maybe i am just borrowing the outer shape of senior work without having the same foundation behind it.
what i am still learning
to be fair, it is not true that nothing is being learned.
i am still learning all the time, just in a different shape.
i am learning:
- how systems fit together
- what kinds of abstractions feel clean or fake
- how to notice when something is overbuilt
- how to redirect implementation toward the thing i actually mean
- how to review output and find what feels wrong
- how to keep momentum in projects that would otherwise stall
that is real learning. it is not fake just because it is less painful.
the problem is that it may be uneven learning.
it builds judgment faster than muscle. it builds taste faster than recall. it builds supervision faster than low-level confidence.
and i do not yet know if that imbalance is fine, dangerous, or just the new normal.
maybe i never liked coding for the reasons people romanticize
part of this may just be that i like a different layer of the work than the one people often glorify.
i like:
- structure
- systems
- concepts
- flows
- tools
- user-facing clarity
- making messy things feel coherent
i do not naturally love:
- syntax for its own sake
- long doc reading sessions
- boilerplate
- terminal ritual
- repetitive debugging that teaches the same lesson in a slightly different way
- copying and patching small details until something finally stops complaining
that has always been true to some degree.
so maybe ai is not pulling me away from my real way of working. maybe it is revealing it.
maybe i was never really trying to become someone who enjoys every layer equally. maybe i was always trying to get to the layer where intent, structure, and usefulness become clearer.
but something can still get lost
even if that is true, i still think something can be lost if i outsource too much of the friction.
mistakes teach things. debugging teaches things. reading docs closely teaches things. writing the wrong code yourself and seeing exactly why it fails teaches things in a way that watching a correct answer appear does not.
there is also a kind of confidence that only comes from being able to rebuild part of a system without help.
not just recognizing it. not just following it. not just editing it well.
actually rebuilding it.
and i do not want to wake up one day realizing that i can prompt very well, supervise very well, maybe even think architecturally pretty well, but no longer trust myself to push through the lower-level work when it really matters.
maybe the real question is what i still want to keep for myself
so maybe the right question is not whether ai is good or bad for learning.
maybe the better question is:
which parts of learning do i still want to keep for myself, and which parts am i happy to outsource?
there are probably layers i am fully happy to let go of:
- repetitive setup
- syntax lookups
- glue code
- deployment routines
- config busywork
and then there are layers i probably should not fully give away:
- understanding the structure of the system
- being able to trace failures
- knowing what the code is actually doing
- recognizing where something is fragile
- being able to survive without perfect assistance
that feels closer to the real tradeoff than the usual dramatic talk about ai replacing everything.
this post is part of the problem too
and even this post proves the point a little bit.
i laid out the idea, the tension, and the examples. then ai helped turn it into a more coherent written note.
that is useful. it also means i skipped some of the slow work of writing my way toward the thought manually.
so even here the pattern repeats:
i like the leverage. i distrust what it might remove. i still use it.
for now, maybe the most honest thing i can say is this:
ai helps me build in a way that fits me unusually well. it removes a lot of the work i genuinely dislike. it lets me stay closer to the conceptual and structural layer that i actually care about.
but i am not fully convinced that the layers below that have stopped mattering.
maybe they matter less. maybe they matter differently. maybe they matter most exactly when everything above them starts failing.
i do not have a clean conclusion yet.
only the feeling that i am gaining speed, leverage, and clarity at the same time as i may be giving up some forms of hard-earned understanding.
and that trade still feels worth examining carefully, especially because i like it so much.