Flexibility is a False God

I oft-times see the ease with which a program may be changed touted as some innate good.  I disagree
to some degree.  Such ease is usually good, and usually preferable without other constraints, but it
also makes certain kinds of software harder to craft, and flexibility is a vague concept which leads
many down a path of ruin.  In all cases, software is best when as simple, and as short, as possible.

Dynamic typing is a quality more important than any other for flexibility as it's usually described.
Dynamic typing is pleasant at system boundaries and for other things preventing guarantees as to the
shape and qualities of data, but frustrates the programmer easily in other instances; weak typing is
a solution to this frustration, with the costs of program correctness and comprehensibility.  Strong
typing is most reasonable in most things, and pairs well enough with dynamic typing, but any systems
which allow the programmer to make simple mistakes are flawed in some way.  Static and strong typing
are paramount where correctness be most important, and I can only see incorrectness as unacceptable.

Unfortunately, correct systems are necessarily less flexible than incorrect systems, as an incorrect
system may be changed and remain just as incorrect whereas a correct system has no similar identity.

To make a correct system flexible is arguably impossible, for it's always possible to find a new way
such a system should be flexible in a way it can't without changes.  The only reasonable solution is
to shun the idea of flexibility, perhaps.  To contort some program according to some new want may be
unreasonable, compared to crafting some new program which may very well take the same or less effort
as the adaptation would.  Shorter programs aren't strictly easier to craft than longer programs, but
they're usually easier to change directly, if only because they can be more easily understood.  If a
program fits ``on one line'' or ``on the screen'' or ``with few moving parts'' or be tiny by another
metric, it's very likely easier to comprehend than a program without such characteristics; a program
whose whole is but an arrangement of few, more complex pieces has no need for flexibility, since any
new and somewhat similar programs would be easier to craft from scratch, in overwhelming likelihood.

I see no way in which flexibility be preferable to simplicity, and such simplicity gives many of the
same things flexibility supposedly provides; there's no need for flexibility when software be easier
to change, and so the difficulty of changing most software in any meaningful way is that true issue.
.